초보코더의 메모장

 FROM docker.io/centos:7.4.1708

# 사용자 지정

USER root

# 언어셋 설치

RUN yum clean all \

 && yum repolist \

 && yum -y update \

 && sed -i "s/en_US/all/" /etc/yum.conf  \

 && yum -y reinstall glibc-common

# 기본적으로 필요한 OS 패키지를 설치한다.

RUN  yum -y install tar unzip vi vim telnet net-tools curl openssl \

 && yum -y install apr apr-util apr-devel apr-util-devel \

 && yum -y install elinks locate python-setuptools \

 && yum clean all

RUN yum install -y openssh-server \

    && yum install -y sudo

ENV LANG=ko_KR.utf8 TZ=Asia/Seoul

RUN echo "root:root" | chpasswd

# 컨테이너 실행시 실행될 명령

CMD ["/bin/bash"]

 docker build -t centosksh:v1 .

 docker run --privileged -it -e container=docker -v /sys/fs/cgroup:/sys/fs/cgroup:ro -p 22 --name=centosksh1 centosksh:v1 /usr/sbin/init

 docker run --privileged -it -e container=docker -v /sys/fs/cgroup:/sys/fs/cgroup:ro -p 32000:22 --name=centosksh2 centosksh:v1 /usr/sbin/init

service sshd start 

ssh -p 32772 root@localhost

ssh -p 32000 root@localhost 

@Component

@Configuration

public class RedisConnectionConfig {

  @Value("${redis.host}")

  private String redisHost;

  @Value("${redis.port}")

  private int redisPort;

  @Bean

  public RedisConnectionFactory XXXRedisConnectionFactory() {

    JedisPoolConfig poolConfig = new JedisPoolConfig();

    poolConfig.setMaxTotal(5);

    poolConfig.setJmxNamePrefix("redispool");

    poolConfig.setJmxNameBase("redis.client.jedis:type=XXXSentinelPool,name=");

    JedisConnectionFactory connectionFactory = new JedisConnectionFactory(poolConfig);

    connectionFactory.setUsePool(true);

    connectionFactory.setHostName(redisHost);

    connectionFactory.setPort(redisPort);

    return connectionFactory;

  }

}

@Getter

@Setter

public class XXXRedisTemplate<K, V> extends RedisTemplate {

  private String cacheName;

} 

@Slf4j

public class XXXRedisSingleSerializer<T> implements RedisSerializer<Object> {

  private Class<?> clazz;

  private ObjectMapper objectMapper = new ObjectMapper();

  public XXXRedisSingleSerializer(Class<?> clazz) {

    this.clazz = clazz;

  }

  @Override

  public byte[] serialize(Object o) throws SerializationException {

    try {

      return objectMapper.writeValueAsBytes(o);

    } catch (IOException e) {

      log.warn("serialize exception list :  {}, message : {}", o, e.getMessage(), e);

    }

    return null;

  }

  @Override

  public T deserialize(byte[] bytes) throws SerializationException {

    try {

      Object o = objectMapper.readValue(bytes, objectMapper.getTypeFactory().constructType(clazz));

      return (T) o;

    } catch (IOException e) {

      log.warn("deserialize exception data :  {}, message : {}", bytes, e.getMessage(), e);

    }

    return null;

  }

}

@Slf4j

public class XXXRedisSerializer implements RedisSerializer<List> {

  private Class<?> clazz;

  private ObjectMapper objectMapper = new ObjectMapper();

  public XXXRedisSerializer(Class<?> clazz) {

    this.clazz = clazz;

  }

  @Override

  public byte[] serialize(List ts) throws SerializationException {

    try {

      return objectMapper.writeValueAsBytes(ts);

    } catch (IOException e) {

      log.warn("serialize exception list :  {}, message : {}", ts, e.getMessage(), e);

    }

    return null;

  }

  @Override

  public List deserialize(byte[] bytes) throws SerializationException {

    try {

      List<?> list =

          objectMapper.readValue(

              bytes, objectMapper.getTypeFactory().constructCollectionType(List.class, clazz));

      return list;

    } catch (IOException e) {

      log.warn("deserialize exception data :  {}, message : {}", bytes, e.getMessage(), e);

    }

    return Lists.newArrayList();

  }

}

@Configuration

public class XXXRedisTemplateConfig {

  @Autowired

  @Qualifier("XXXRedisConnectionFactory")

  private RedisConnectionFactory XXXPortalRedisConnectionFactory;

  @Bean

  public XXXRedisTemplate<String, XXXdto1> xxx1RedisTemplate() {

    return redisTemplate(XXXdto1.class, XXXCacheConst.XXX1);

  }

  @Bean

  public XXXRedisTemplate<String, xxx2Dto> xxx2Template() {

    XXXRedisTemplate<String, xxx2Dto> redisTemplate =

        new XXXRedisTemplate<>();

    redisTemplate.setKeySerializer(new StringRedisSerializer());

    redisTemplate.setValueSerializer(

        new XXXRedisSingleSerializer<xxx2Dto>(xxx2Dto));

    redisTemplate.setConnectionFactory(XXXRedisConnectionFactory);

    redisTemplate.setCacheName(XXXCacheConst.xxx2);

    return redisTemplate;

  }

  @NotNull

  private XXXRedisTemplate redisTemplate(Class<?> clazz, String cacheName) {

    XXXRedisTemplate redisTemplate = new XXXRedisTemplate<>();

    redisTemplate.setKeySerializer(new StringRedisSerializer());

    redisTemplate.setValueSerializer(new XXXRedisSerializer(clazz));

    redisTemplate.setConnectionFactory(XXXRedisConnectionFactory);

    redisTemplate.setCacheName(cacheName);

    return redisTemplate;

  }

} 

  @Autowired private List<XXXRedisTemplate> XXXRedisTemplates;

  @Bean

  public CacheManager cacheManager() {

    List<RedisCacheManager> cacheManagers =

        XXXRedisTemplates

            .stream()

            .map(

                redisTemplate -> {

                  RedisCacheManager redisCacheManager = new RedisCacheManager(redisTemplate);

                  redisCacheManager.setCacheNames(Lists.newArrayList(redisTemplate.getCacheName()));

                  redisCacheManager.setDefaultExpiration(300);

                  redisCacheManager.afterPropertiesSet();

                  return redisCacheManager;

                })

            .collect(Collectors.toList());

    CompositeCacheManager compositeCacheManager = new CompositeCacheManager();

    compositeCacheManager.setCacheManagers(Lists.newArrayList(cacheManagers));

    return compositeCacheManager;

  }

}