Kamsi's Blog

Eclipse IDE 2020‑03 을 다운받아 사용하려는데 Market에 PropertiesEditor이 없다..ㅡㅡ;;;;;

예전 것은 있으나 지원이 안된다고 한다..

그래서 결론은 수동으로 처리 해야 함.

다운로드 URL : http://propedit.sourceforge.jp/eclipse/updates 

여기서 PropertiesEditor 만 설치 하면 됨.

기본적으로 gradle 설치가 되어 있어야 한다.

바꾸는 명령어는 간단하다.

pom.xml이 있는 경로로 가서 

gradle init --type pom

이렇게 명령어를 실행하면 된다.

테스트 결과 완벽하게 모든 dependencies 옮겨지지 않는다.

일부 손이 가야 하지만 그래도 Maven보다 빠르고 쓰기 편하니 그걸로 족하다.

나 같은 경우 서브업무로 업무가 분리되어 있는 경우 업무를 처리하고 특정 Interface를 구현한 Class를 찾아서 후처리하는 기능 때문에 필요한 기능이었습니다.

추가적으로 찾은 Class에서 특정 Annotaion을 사용한 Method를 찾아서 실행하도록 하였습니다.

ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false); 
provider.addIncludeFilter(new AssignableTypeFilter(Interface명.class));

Set components = provider.findCandidateComponents("Package명");  // co/kr/test형식

for (BeanDefinition component : components) {
    Class<?> clazz = Class.forName(component.getBeanClassName());
    logger.debug("Class Name : " + clazz.getName() );

    Method[] methods = clazz.getMethods();
    for (Method method : methods) {
        if( method.isAnnotationPresent(PostApprove.class) ) {
            logger.debug("Method Name : " + method.getName() );
            PostApprove annotation = method.getAnnotation(Annotation명.class);
            logger.debug("Annotation CODE : " + code + ", KEY : " + key );

            if( Arrays.asList(annotation.code()).contains(code) ) {
                String serviceValue = method.getDeclaringClass().getAnnotationsByType(Service.class)[0].value();
                ApproveHelper helper = (ApproveHelper) context.getBean(serviceValue);
         helper.postApprove(code, key);
           }
        }
    }
}

Java Configuration을 사용할 경우

public class WebMvcConfig extends WebMvcConfigurerAdapter {

@Override

public void addResourceHandlers(ResourceHandlerRegistry registry) {

registry

.addResourceHandler("/resources/**")

.addResourceLocations(

"/resources/",

"classpath:/META-INF/resources/resources"

);

}

}

xml 설정을 사용할 경우

<resources mapping="/resources/**" location="classpath:/META-INF/resources/resources/" />

- ajax로 보낼 경우

@RequestParam(value="arr[]" String[] arr)

- get 또는 post로 보낼 경우

@RequestParam(value="arr" String[] arr)

Data를 저장 시 저장되는 모든 정보를 이력으로 남겨 놓기 위하여 작성했습니다.

말들이 하도 많아서...ㅜㅜ

import java.lang.reflect.Method;

import java.util.Enumeration;

import javax.annotation.Resource;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang3.ArrayUtils;

import org.apache.commons.lang3.StringUtils;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.reflect.MethodSignature;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.security.core.context.SecurityContextHolder;

import org.springframework.security.core.userdetails.UserDetails;

import org.springframework.stereotype.Component;

import org.springframework.util.ObjectUtils;

import org.springframework.web.context.request.RequestContextHolder;

import org.springframework.web.context.request.ServletRequestAttributes;

import com.duegosystem.esh.common.utils.RequestUtils;

import com.duegosystem.esh.config.aspect.operate.annotation.OperateLog;

import com.duegosystem.esh.config.aspect.operate.service.UserOpertHistService;

import com.duegosystem.esh.config.aspect.operate.vo.OperateHistVo;

import com.duegosystem.esh.config.security.vo.UserVo;

/**

 * @author Duego-Choi

 *

 */

@Aspect

@Component

public class OperateAdviceLogging {

private static final Logger logger = LoggerFactory.getLogger(OperateAdviceLogging.class);

@Resource(name = "userOpertHistService")

private UserOpertHistService userOpertHistService;

/**

* 등록 수정 삭제 시에만 적용합니다.

*

* @param joinPoint

* @return

* @throws Throwable

*/

@Around("execution(* com.duegosystem..*Controller.insert*(..)) || "

+ "execution(* com.duegosystem..*Controller.update*(..)) || "

+ "execution(* com.duegosystem..*Controller.delete*(..))")

public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {

logger.debug("Operate History Logging save processing.......................................");

Object principal = (Object) SecurityContextHolder.getContext().getAuthentication().getPrincipal();

HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes())

.getRequest();

String httpMethod = request.getMethod();

MethodSignature signature = (MethodSignature) joinPoint.getSignature();

Method method = signature.getMethod();

logger.debug("httpMethod : " + httpMethod);

logger.debug("Class Method : " + method);

OperateHistVo operateHistVo = null;

/*

* 저장 수정 삭제 일경우만 사용하도록 하기 위해 POST 형식일 때만 적용되어지도록 처리

*/

if ("POST".equals(httpMethod)) {

if ((principal instanceof UserDetails)) {

operateHistVo = new OperateHistVo();

// 사용자 정보

UserVo user = (UserVo) principal;

logger.debug("empno : " + user.getEmpno());

logger.debug("emplNm : " + user.getEmplNm());

operateHistVo.setOpertId(user.getEmpno());

operateHistVo.setOpertNm(user.getEmplNm());

// 작업자 아이피

String ipAddress = RequestUtils.getRemoteIP(request);

logger.debug("ipAddress : " + ipAddress);

operateHistVo.setOpertIp(ipAddress);

// 접근 경로(메뉴 패턴)

String requestUri = request.getRequestURI();

String contextPath = request.getContextPath();

String pattern = requestUri.replaceAll("(^" + contextPath + ")|((\\.[^\\.]*)$)|((/[^/]+){1}/*$)", "")

+ "/";

logger.debug("Url pattern : " + pattern);

operateHistVo.setPattern(pattern);

String operateFile = requestUri.replace(contextPath, "").replace(pattern, "");

String operateType = "insert";

if (operateFile.startsWith("update")) {

operateType = "update";

} else if (operateFile.startsWith("delete")) {

operateType = "delete";

}

logger.debug("Operate Type : " + operateType);

operateHistVo.setOpertTy(operateType);

/*

* OperateLog Annotation을 통해서 등록하고자 하는 파라메터 또는 등록지 말아야 할 파라메터를

* 지정하였을 경우 처리합니다.

*

* 우선 순위는 등록해야할 파라메터가 있는 경우가 우선입니다.

*/

Enumeration<String> params = request.getParameterNames();

if (method.isAnnotationPresent(OperateLog.class)) {

OperateLog operateLog = method.getDeclaredAnnotation(OperateLog.class);

String[] saveParams = operateLog.params();

String[] notSaveParams = operateLog.notSaveParam();

// 저장하고자 하는 파라메타명을 설정하였을 경우

if (!ObjectUtils.isEmpty(saveParams)) {

while (params.hasMoreElements()) {

String paramName = (String) params.nextElement();

if (ArrayUtils.contains(saveParams, paramName)) {

if (!StringUtils.isEmpty(request.getParameter(paramName))) {

operateHistVo.addParam(paramName, request.getParameter(paramName));

}

}

}

// 저장하지 않을 파라메타명을 성정하였을 경우

} else if (!ObjectUtils.isEmpty(notSaveParams)) {

while (params.hasMoreElements()) {

String paramName = (String) params.nextElement();

if (ArrayUtils.contains(notSaveParams, paramName)) {

continue;

} else {

if (!StringUtils.isEmpty(request.getParameter(paramName))) {

operateHistVo.addParam(paramName, request.getParameter(paramName));

}

}

}

} else {

while (params.hasMoreElements()) {

String paramName = (String) params.nextElement();

if (!StringUtils.isEmpty(request.getParameter(paramName))) {

operateHistVo.addParam(paramName, request.getParameter(paramName));

}

}

}

} else {

while (params.hasMoreElements()) {

String paramName = (String) params.nextElement();

if (!StringUtils.isEmpty(request.getParameter(paramName))) {

operateHistVo.addParam(paramName, request.getParameter(paramName));

}

}

}

userOpertHistService.insert(operateHistVo);

}

}

Object obj = joinPoint.proceed();

/*

* Method에 해당하는 처리가 모두 끝난 후 후처리로 성공 상태 값을 Y로 바꿔준다.

*/

if ("POST".equals(httpMethod)) {

if (!ObjectUtils.isEmpty(operateHistVo)) {

try {

userOpertHistService.updateSuccess(operateHistVo.getOpertHistSeq());

} catch (Exception e) {

logger.error("OperateHist Advice Processing Error......!!!", e);

}

}

}

return obj;

}

}

Spring에서 코드성을 체크하는 validation 없어서 생성하기로 맘먹고 구글링 시작....^ ^

package com.company.common.validation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import javax.validation.Constraint;
import javax.validation.Payload;

@Documented
@Constraint(validatedBy=EnumConstraintValidator.class)
@Target( {ElementType.METHOD, ElementType.FIELD } )
@Retention(RetentionPolicy.RUNTIME)
public @interface Enum {

 String message() default "{message.validation.constraints.enum}";

 Class<?>[] groups() default{};

 Class<? extends Payload>[] payload() default {};

 String[] values() default {};

}

위와 같이 생성을 하고 나중에 이를 사용하게 됩니다. (@Enum)

그리고 아래 소스는 Validation 체크 하는 로직을 담당하는 소스입니다.

package com.company.common.validation;

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

import org.apache.commons.lang3.ArrayUtils;

public class EnumConstraintValidator implements ConstraintValidator<Enum, String> {

 private String[] values;

 @Override
 public void initialize(Enum constraint) {
   values = constraint.values();
 }

 @Override
 public boolean isValid(String value, ConstraintValidatorContext context) {

  if( null == value ) return false;

  if( ArrayUtils.indexOf(values, value) > -1 ) return true;

  return false;
 }

}

사용은 아래와 같이~~~~

public class PayHist {

 @NotEmpty(groups={InsertProc.class})
 @Length(max=1)
 @Enum(values={"C","F"})
 private String gubun;           //서비스종류 : C-유료서비스 고객, F-무료서비스 고객

...

values :  허용되는 값 목록

values와 해당 값을 비교하여 일치 하지 않을 경우 오류를 발생합니다.

또한 default message 설정은 이클립스 resources 최상위에다가....

ValidationMessages.properties 이름으로 생성하여 주면 properties를 사용하여 메시지 출력이 가능합니다..ㅡㅡ;;

message.validation.constraints.enum={values} 만 등록이 가능합니다.

다른데 넣으면 안되더라구요...

Caused by: java.lang.IllegalStateException: Ambiguous mapping found. Cannot map 'socialController' bean method 

원인 : Controller에 동일한 RequestMapping가 설정되어 있을경우 발생

@PropertySource로 Property 파일을 Evnironment로 로딩을 합니다.

아래는 예제 Sample입니다.

package com.intercast.schedule.dao;

 

import javax.annotation.Resource;

 

import org.springframework.context.MessageSource;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Repository;

 

@Repository("excelDao")
@PropertySource("classpath:properties/globals.properties")
public class ExcelDao {

 

 @Resource
 private MessageSource messageSource;

 

 @Resource
 private Environment environment;

 

 public void getExcelInfo() {
  System.out.println( "UPLOAD_FILE_PATH : " + environment.getProperty("UPLOAD_FILE_PATH") );
 }

}

굵은 글씨로 표시 한 부분이 해당 property를 inject 하고 사용하는 곳입니다.

프로퍼티가 여러개 일 경우에는 @PropertySources Annotation을 사용하시면 됩니다.

이제 마지막으로 자바를 구동하는 Application 파일입니다.

package com.intercast.schedule.stater;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import com.intercast.config.AppConfig;

 

public class Application {

 

 @SuppressWarnings("resource")
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  new AnnotationConfigApplicationContext(AppConfig.class);
 }

 

}

AnnotationConfigApplicationContext 을 이용하여 Spring 설정파일을 등록하고 실행하면 됩니다.

실행 : java -jar 자르파일명

실질적으로 Schedule를 설정하는 java 파일입니다.

package com.intercast.schedule.service;

import javax.annotation.Resource;

import org.springframework.scheduling.annotation.Scheduled;

 

public class Demon {

 

 @Resource(name="scheduleService") ScheduleService scheduleService;

 

 @Scheduled(cron="0/5 * * * * *")
 public void printHello() {
  scheduleService.insertUser();
 }

 

}

보시는 바와 같이 @Scheduled를 설정합니다.

Scheduled 설정에 관하여서는 따로 설명을 드리지 않겠습니다.

저의 경에는 cron을 사용하여 설정을 하였습니다.

이후의 방식은 MVC 방식의 Service 및 DAO 구현과 동일하게 진행하시면 됩니다.

Spring 설정은 두가지만 설정하면 됩니다.

Spring Scheduling 기본설정의 AppConfig.java와 Database 설정을 담당할 DatabaseConfig.java 입니다.

AppConfig.java 

package com.intercast.config;

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

import org.springframework.context.MessageSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;

import com.intercast.schedule.service.Demon;

 

@Configuration
@ComponentScan(value="com.intercast.schedule")
@EnableScheduling
@Import({DatabaseConfig.class})
public class AppConfig implements SchedulingConfigurer {

 

 @Bean
 public Demon demon() {
  return new Demon();
 }

 

 @Override
 public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
  // TODO Auto-generated method stub
  taskRegistrar.setScheduler(taskExecutor());
 }

 

 private Executor taskExecutor() {
  // TODO Auto-generated method stub
  return Executors.newScheduledThreadPool(10);
 }

 

}

위의 항목중에 @EnableScheduling 부분이 Annotation으로 설정된 @Scheduled 를 찾아 등록하고 실행 해 주는 부분입니다.

Demon을 Bean으로 등록을 하고 Demon에서 Schedule clon 설정을 해 주므로 구동이 시작됩니다.

DatabaseConfig 설정은 기존 Spring4 Java Config를 확인하시면 됩니다.