비밀번호 전송 양방향 암호화(rsa) 적용

  • view에서 서버로 계속 같은 비밀번호 전송하는걸 막기위해 rsa 양방향 암호화 적용

1.Rsa util 추가

import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.RSAPublicKeySpec;
import javax.crypto.Cipher;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

public class Rsa {

    public static String RSA_WEB_KEY = "_RSA_WEB_Key_"; // 개인키 session key
    public static String RSA_INSTANCE = "RSA"; // rsa transformation

    /**
     * 복호화
     *
     * @param privateKey
     * @param securedValue
     * @return
     * @throws Exception
     */
    public String decryptRsa(PrivateKey privateKey, String securedValue) throws Exception {
        Cipher cipher = Cipher.getInstance(Rsa.RSA_INSTANCE);
        byte[] encryptedBytes = hexToByteArray(securedValue);
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] decryptedBytes = cipher.doFinal(encryptedBytes);
        String decryptedValue = new String(decryptedBytes, "utf-8"); // 문자 인코딩 주의.
        return decryptedValue;
    }

    /**
     * 16진 문자열을 byte 배열로 변환한다.
     *
     * @param hex
     * @return
     */
    public static byte[] hexToByteArray(String hex) {
        if (hex == null || hex.length() % 2 != 0) { return new byte[] {}; }

        byte[] bytes = new byte[hex.length() / 2];
        for (int i = 0; i < hex.length(); i += 2) {
            byte value = (byte) Integer.parseInt(hex.substring(i, i + 2), 16);
            bytes[(int) Math.floor(i / 2)] = value;
        }
        return bytes;
    }

    /**
     * rsa 공개키, 개인키 생성
     *
     * @param request
     */
    public void initRsa(HttpServletRequest request) {
        HttpSession session = request.getSession();

        KeyPairGenerator generator;
        try {
            generator = KeyPairGenerator.getInstance(Rsa.RSA_INSTANCE);
            generator.initialize(1024);

            KeyPair keyPair = generator.genKeyPair();
            KeyFactory keyFactory = KeyFactory.getInstance(Rsa.RSA_INSTANCE);
            PublicKey publicKey = keyPair.getPublic();
            PrivateKey privateKey = keyPair.getPrivate();

            session.setAttribute(Rsa.RSA_WEB_KEY, privateKey); // session에 RSA 개인키를 세션에 저장

            RSAPublicKeySpec publicSpec = (RSAPublicKeySpec) keyFactory.getKeySpec(publicKey, RSAPublicKeySpec.class);
            String publicKeyModulus = publicSpec.getModulus().toString(16);
            String publicKeyExponent = publicSpec.getPublicExponent().toString(16);

            request.setAttribute("RSAModulus", publicKeyModulus); // rsa modulus 를 request 에 추가
            request.setAttribute("RSAExponent", publicKeyExponent); // rsa exponent 를 request 에 추가
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

2. jsp에 필요 js 추가 및 hidden 값추가

<script type="text/javascript" src="${_.contextPath}/resources/lib/RSA/rsa.js"></script>
<script type="text/javascript" src="${_.contextPath}/resources/lib/RSA/jsbn.js"></script>
<script type="text/javascript" src="${_.contextPath}/resources/lib/RSA/prng4.js"></script>
<script type="text/javascript" src="${_.contextPath}/resources/lib/RSA/rng.js"></script>
<form> ...
                                <input type="hidden" id="RSAModulus" value="${RSAModulus}"/>
                                <input type="hidden" id="RSAExponent" value="${RSAExponent}"/>
</form>

3. js에 암호화 로직 추가 및 암호화

// 비밀번호 암호화
function rsa(pwd){
    var pw = pwd;
    // rsa 암호화
    var rsa = new RSAKey();
    rsa.setPublic($('#RSAModulus').val(),$('#RSAExponent').val());
    return rsa.encrypt(pw);
}
function bindLoginSubmit() {
  $("#form_login").submit(function (e) {
    e.preventDefault();
    var form = this;
    var options = {
      method: form.method
      /*, data: $(form).serialize()*/
      , data: {
          "username" :  rsa($("input[name='username']").val())
          ,"password" : rsa($("input[name='password']").val())
      }
    };
})
};

4. WebSecurityConfig에 RequestContextListener 추가 (HttpRequest 불러오기위해)

    @Bean
    public RequestContextListener requestContextListener(){
        return new RequestContextListener();
    }

5. 복호화 및 암호화 AuthenticationProvider에 추가

    @Override
    public Authentication authenticate(Authentication authentication) throws AuthenticationException {
        try {
            ServletRequestAttributes servletRequestAttribute = (ServletRequestAttributes) RequestContextHolder.currentRequestAttributes();
            HttpServletRequest request = servletRequestAttribute.getRequest();
            Rsa r = new Rsa();
            HttpSession session = request.getSession();
            //로그인전에 세션에 저장된 개인키를 가져온다.
            PrivateKey privateKey = (PrivateKey) session.getAttribute(Rsa.RSA_WEB_KEY);
            //암호화 된 비밀번호를 복호화 시킨다.
            String username = r.decryptRsa(privateKey, (String) authentication.getPrincipal());
            String password = r.decryptRsa(privateKey, (String) authentication.getCredentials());
            // ShA 256 암호화 = 단방향
            password = passwordEncoder.encode(password).replaceAll("\\{sha256}","");
        }
}

스프링 빈이란?

스프링이 객체를 생성해 들고 있는다.

즉, 스프링 컨테이너가 생성될 때 컨트롤러(빈)가 같이 생성된다.

 

why?

객체를 계속 생성할 필요가 없고 미리 생성해 그것을 사용한다.

 

빈과 의존관계

 

컨트롤러(@Controller) -> 서비스

컨트롤러로 요청이 들어오면 서비스를 통해 비즈니스 작업을 해야 하기에 컨트롤러가 서비스에 의존한다.

 

의존관계 주입방법

컨트롤러, 서비스를 다 빈으로 등록해준다.

의존관계를 생성할 땐 @Autowired를 사용한다.

 

빈등 록 방식

1. 컴포넌트 스캔

2. 자바 코드로 스프링 빈 등록

 

빈 등록은 메인 메서드가 있는 패키지부터 시작한다.

즉, 하위 패키지에 있는 것만 등록된다.


자바 코드로 빈 등록하기

 

@Configuration

public class SpringConfig {



    @Bean

    public MemberService memberService() {

        return new MemberService(memberRepository());

    }



    @Bean

    public MemberRepository memberRepository(){

        return new MemoryMemberRepository();

    }

}

애노테이션으로 등록하기

@Aspect
@Component
public class TimeTraceAop {

    @Around("execution(* hello.hellospring..*(..))")
    public Object execute(ProceedingJoinPoint joinPoint) throws Throwable {
        long start =  System.currentTimeMillis();
        try {
            return joinPoint.proceed();
        } finally {
            long finish = System.currentTimeMillis();
            long timeMs = finish - start;
            System.out.println(joinPoint.toString()+" / timeMs : "+timeMs+"ms");
        }

    }
}

@Component,@Service,@Repository 대신 자바로 등록할 수 있다.

정형화된 코드(@Service,@Repository)는 컴포넌트 스캔을 사용한다.

 

또, 생성자로 빈을 생성하는 게 제일 안전하다.

    private final MemberRepository memberRepository;
	
    //생성자
    @Autowired
    public MemberService(MemberRepository memberRepository) {
        this.memberRepository = memberRepository;
    }

스프링 웹 개발 기초

 

1. 정적 컨텐츠

서버에서 파일을 웹브라우저에 그냥 내려준다.

resources 경로 안에 static, public안에 html은 스프링 부트에서 자동으로 올려준다.

/hello-spring/src/main/resources/static 경로 안 파일 확인

-rw-r--r--  1 mac  staff  222  8  9 14:10 hello-static.html

-rw-r--r--  1 mac  staff  227  8  9 10:52 index.html

 

정적컨텐츠 가져오는 순서

클라이언트 요청 -> 컨트롤러 체크(우선순위는 컨트롤러) -> 없을 경우 static, public 경로 파일 있는지 확인

 

2.MVC와 템플릿 엔진

Model View Controller

 

View : 화면을 그리는데 집중해야 한다.

Model, Controller : 비지니스 로직에 집중한다.

 

Code

@GetMapping("hello-mvc")

public String helloMvc(@RequestParam(value = "name") String name, Model model){

    model.addAttribute("name",name);

    return "hello-template";

}

 

 

3.API

View를 사용하지 않고 데이터를 바로 내릴 수 있다.

@ResponseBody를 사용할 경우 viewResolver 대신 httpMessageConverter가 동작한다.

기본 문자 처리

StringMessageConverter

기본 객체 처리

MappingJackson2 MessageConverter

요새는 보통 json형태로 데이터를 제공해준다.

Ex)

{

"name": "test"

}

 

Code

@GetMapping("hello-string")

@ResponseBody

public String helloString(@RequestParam(value = "name") String name, Model model){

    return "hello "+name;

}

'개발 소발 > 개발 Spring' 카테고리의 다른 글

Spring form login RSA 암호화 적용  (0) 2022.08.18
Spring Bean,스프링 빈이란?기초  (0) 2021.08.13
Spring DispatcherServlet 기초개념  (0) 2020.08.06
Spring Environment 기초 사용방법  (0) 2020.07.13
Spring Scope란?  (0) 2020.07.13

스프링 이전에 Servlet을 직접 사용할땐 URL마다 하나하나 만들어야하고

 

각각의 설정하기가 매우 복잡했다.

 

이것을 해결하는것이 Spring의 dispatcherServlet이다.

매번 반복작업하던 비생산적인 작업들을 스프링이 뒷단에서 직업해주고 있다.

 

HandlerMapping 으로 클라이언트가 서버에 요청할때 접근할 수 있게 해주고

HandlerAdapter로 요청에 맞는 기능을 찾아준다.

//스프링 내부 소스코드
//스프링이 구동될떄 초기에 여러 형태를 미리 준비해놓을 수 있다.

protected void initStrategies(ApplicationContext context) {
    this.initMultipartResolver(context);
    this.initLocaleResolver(context);
    this.initThemeResolver(context);
    this.initHandlerMappings(context);
    this.initHandlerAdapters(context);
    this.initHandlerExceptionResolvers(context);
    this.initRequestToViewNameTranslator(context);
    this.initViewResolvers(context);
    this.initFlashMapManager(context);
}

또 한 여러 작업을 하고 클라이언트에게 다시 송출할때도

viewResolver로 보내준다.

viewResolver는 기본으로 제공해주지만 아래처럼 커스텀해서 사용할 수 있다.

//viewResolver 설정해서 간단하게 사용하기

@Configuration
@ComponentScan
public class OneServletWebConfig {

    @Bean
    public ViewResolver viewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/WEB-INF/");
        viewResolver.setSuffix(".jsp");
        return viewResolver;
    }
}

 

요청을 받고 요청의 맞는 기능을 구현하고 형태에 맞게 화면에 전송하는 것을 다구현하지않고

스프링의  dispatcherServlet이 구현해준다.

Environment

 

Application Context은 Bean Factory기능만 하는게 아니다.

Application Context의 기능은 여러가지가 있다.

 

그 중하나가 Environment이다.(환경설정)

 

Environment 프로파일(Profile) 

프로파일이란 Bean들의 묶음 특정 Bean들을 묶어 사용할때 유용하다.

 

@Profile로 ComponentScan으로 등록할 수 있고 

@Repository

@Profile("!prod")//ComponentScan에 등록하기

public class TestBookRepository implements BookRepository{



    @PostConstruct

    @Override

    public void run() {

        System.out.println("TestBookRepository 생성");

    }

}

 

@Configuration을 통해 Class형식으로 등록할 수있다 

//profile정하고 class로 등록하는방법

@Configuration

@Profile("test")//test profile일때만 사용

public class TestConfiguration {



    @Bean

    public BookRepository bookRepository(){

        return new TestBookRepository();

    }

}

또 특정 profile만 실행하는 것이 아닌 특정 프로파일이 아닐때도 사용가능하다. !not 사용

prod Profile이 아닐때 예제코드

@Repository
@Profile("!prod")//ComponentScan에 등록하기
public class TestBookRepository implements BookRepository{

    @PostConstruct
    @Override
    public void run() {
        System.out.println("TestBookRepository 생성");
    }
}

 

environment를 통해 properties 사용하기

Configuraion에 VMoption을 등록하거나

resources 경로 아래 Properties 파일을 생성하고

스프링시작부분에 @PropertySource("classpath:./App.Properties”)를 등록하고

꺼내올 수 있다.

@SpringBootApplication

@PropertySource("classpath:./App.Properties")

public class EnvironApplication {



    public static void main(String[] args) {

        SpringApplication.run(EnvironApplication.class, args);

    }

}

 

 

BeanFactory에 등록된 bean들은 scope가 있다.

 

기본 Scope : Singleton Scope

Singleton Scope 이란?

해당 인스턴스가 하나뿐이다. 같은 인스턴스를 재사용하는 것이다.

 

기본적으론 생성된 bean은 SingletonScope이라 같은 인스턴스을 바라본다.

@Scope("prototype”)를 설정하면 매번 다른 인스턴스를 생성할 수 있다.

 

@Scope(“prototype”)차이점 보기

1.Single Class는 기본 Singleton 스코프

2.Proto Class는 prototype스코프로 선언

 

출력해보면 결과가 다르게 나온다.

@Component

public class Single {



    @Autowired

    Proto proto;



    public Proto getProto() {

        return proto;

    }

}



@Component @Scope("prototype")

public class Proto {

}



@Override

public void run(ApplicationArguments args) throws Exception {

        System.out.println("single");
        System.out.println(context.getBean(Single.class));
        System.out.println(context.getBean("single"));
        System.out.println(single);

        System.out.println("poroto");
        System.out.println(context.getBean(Proto.class));
        System.out.println("----");
        System.out.println(context.getBean("proto"));
        System.out.println("---");
        System.out.println("single.getProto().getClass() : 1----");
        System.out.println(context.getBean(single.getProto().getClass()));
        System.out.println("single.getProto().getClass() : 2----");
        System.out.println(context.getBean(single.getProto().getClass()));
        System.out.println("----같은 인스턴스 보는 이슈");
        System.out.println(context.getBean(Single.class).getProto());
        System.out.println(context.getBean(Single.class).getProto());


}
single
com.choi.scope.Single@4b6e1c0
com.choi.scope.Single@4b6e1c0
com.choi.scope.Single@4b6e1c0
poroto
Proto 인스턴스 생성
com.choi.scope.Proto@26cb5207
----
Proto 인스턴스 생성
com.choi.scope.Proto@15400fff
---
single.getProto().getClass() : 1----
Proto 인스턴스 생성
com.choi.scope.Proto@18d910b3
single.getProto().getClass() : 2----
Proto 인스턴스 생성
com.choi.scope.Proto@1e7ab390
----같은 인스턴스 보는 이슈
com.choi.scope.Proto@11d4dbd6
com.choi.scope.Proto@11d4dbd6

ProtoType에서 Singleton을 Autowired 하면 큰 문제없다.

하지만 Singleton에서 Prototype을 Autowried 한다면?

계속 같은 주소를 불러오는 이슈가 있다.

이때는 @Scope(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS)

설정으로 프록시로 감싸서 사용하면 된다.

 

@Component @Scope(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS)

public class Proto {



    @PostConstruct

    public void main(){

        System.out.println("Test");

        System.out.println("생성자 주입");

        System.out.println("Proto 인스턴스 생성");

    }

}
single
com.choi.scope.Single@2f897dab
com.choi.scope.Single@2f897dab
com.choi.scope.Single@2f897dab
poroto
Proto 인스턴스 생성
com.choi.scope.Proto@39a87e72
----
Proto 인스턴스 생성
com.choi.scope.Proto@5d2828c9
---
single.getProto().getClass() : 1----
Proto 인스턴스 생성
com.choi.scope.Proto@3a082ff4
single.getProto().getClass() : 2----
Proto 인스턴스 생성
com.choi.scope.Proto@45acdd11
----같은 인스턴스 보는 이슈 해결
Proto 인스턴스 생성
com.choi.scope.Proto@3f0d6038
Proto 인스턴스 생성
com.choi.scope.Proto@237f7970

DB 연결을 자주 수정해야 할 때가 있다면 유용하게 사용할 수 있을 것 같다.

 

보통 Singletion 생명주기가 길다. 여러 스레드에서 참조하는 경우 값이 계속바뀔수 있기에 prototype으로 생성하는것이 좋을거 같다.

Autowired란?

빈에서 다른 빈의 의존성을 주입하는것이다.

즉, A bean이 B bean을 사용하려면 @Autowired해준다.

 

Autowired된 bean을 먼저 생성한다. 생각해보면 먼저 생성되어있어야 사용할 수 있다.

@Component
public class BookServiceRunner implements ApplicationRunner {

    //BookService를 사용한다.
    @Autowired
    BookService bookService;

    public void run(ApplicationArguments args) throws Exception{
        bookService.printBookRepository();
    }
}

 

기본적으로는 Autowired를 사용하면 의존성이 있어야하므로 bean으로 등록되어있어야한다.

 

필드,setter에선 (required = false) 으로 의존성을 강제하지 않을 수 있다.

필드에 사용하는것과 생성자에 사용하는건 약간다르다.

    //BookService를 사용한다.
    //의존성 강제 설정해체
    @Autowired (required = false)
    BookService bookService;

 

또 repository가 여러개일 경우 충돌이 난다. 

이럴땐 @Primary나 @Qualifier("huBookRepository")로 강제해주어야한다.

Primary형식

//Primary형식
@Repository @Primary
public class MyBookRepository implements BookRepository {
    @Override
    @PostConstruct
    public void setUp() {
        System.out.println("MyBookRepository");
    }
}

Qualifier형식

    //Qualifier형식
    @Autowired @Qualifier("myBookRepository")
    BookRepository bookRepository;

아니면 모두 사용하고 싶을 경우 LIst형식으로 받을 수 있다.

    @Autowired
    List<BookRepository> bookRepository;

LOG를 찍어보게되면 BookRepository를 implements한 클래스가 모두 나온다

@Service
public class BookService {

    @Autowired
    List<BookRepository> bookRepository;

    public void printBookRepository(){
        this.bookRepository.forEach(System.out::println);
        System.out.println(bookRepository.getClass());
    }
}

인스턴스 생성될때 동작하기 

@Repository
public class MyBookRepository extends TestExtends implements BookRepository  {
    @Override
    @PostConstruct
    public void setUp() {
        System.out.println("MyBookRepository");
    }
}

 

 

 

 

@Component와 컴포넌트 스캔

Component는 스프링 3.1부터 적용되었다.

 

@Component를 사용할 경우 IOC컨테이너에 bean으로 등록한다.

@Service,@Repository,@Controller등 여러가지 애노테이션엔

@Component가 포함되어있다.

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component //Service에 등록되어있는 Component
public @interface Service {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";
}

ComponentScan

여러가지 bean들을 검색하고 IOC컨테이너에 적재한다.

 

스프링부트에선 @SpringBootApplication가 시작지점이 된다.

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

SpringBootApplication 내부 모습

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {

 

@SpringBootApplication 이하의 모든 클래스가 @ComponentScan

(basePackages,basePackageClasses)에 의해 컴포넌트 스캔이된다.

 

만약 개발할때 bean주입이 안되면 컴포넌트 스캔위치를 살펴봐야한다.

모든걸 bean으로 등록하는것이 아니라 필터로 걸러낼 수 있다.

 

, 빈을 다등록하는게 부담된다면 펑션으로 특정빈만 등록할 있다.

'개발 소발 > 개발 Spring' 카테고리의 다른 글

Spring Environment 기초 사용방법  (0) 2020.07.13
Spring Scope란?  (0) 2020.07.13
AOP란? AOP 기초개념  (0) 2020.07.09
Spring IoC(Inversion of Control),Bean,의존성주입이란?  (0) 2020.07.08
프레임워크 개념  (0) 2018.01.26

AOP

Aspect(관심사)

공통된 관심사?로 이해하면 쉽다.

 

여러 클래스에서 같은 로직(관심사)이 실행될 때 사용한다.

 

공통적인 로직을 클래스에 하나하나 추가하지 않고 별도의 클래스로 생성한다.

 

예를 들어 모든 로직의 수행시간을 측정하려고 한다.

//시작

StopWatch sw = new StopWatch();

sw.start();

//여러가지 로직들

//끝

sw.stop();

System.out.println(sw.prettyPrint());

 

공통된 로직이 모두 들어간다.

 

공통된 로직을 분리 후 실행하는방법

 

-컴파일

컴파일할때 코드를 넣어준다.

 

-바이트코드 조작

A.java -> A.Class 하고 실행 시 클래스 로더가 메모리에 올릴 때 조작한다.

 

컴파일, 바이트코드 조작의 차이점 코드가 아닌 메모리에 올라간다.

두 개다 AspectJ가 지원한다.

 

-프록시패턴(스프링AOP)

인터페이스 implements를 통해 구현한다. 

한번 더 감싸는 구조로 생각하면 쉽다.

 

(

공통 로직

(실행 로직)

공통 로직

)

자동으로 bean 등록될 때 만들어진다.

 

 

애노테이션을 사용하여 AOP 적용한 예제

@LogExecutionTime을 만들어보기

@GetMapping("/owners/find")

//만들 애노테이션 명

@LogExecutionTime

public String initFindForm(Map<String, Object> model) {

model.put("owner", new Owner());

return "owners/findOwners";

}

 

구현할 애노테이션 생성

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

public @interface LogExecutionTime {

}

 

 

@Around로 ProceedingJoinPoint를 파라미터로 받는다.

ProceedingJoinPoint는 애노테이션을 설정한 타깃을 말한다.

즉 애노테이션 달려있는 메서드!

//bean으로 등록

@Component

//Aspect 설정

@Aspect

public class LogAspect {



Logger logger = LoggerFactory.getLogger(LogAspect.class);



@Around("@annotation(LogExecutionTime)")

public Object LogExecutionTime(ProceedingJoinPoint joinPoint) throws Throwable{

StopWatch sw =new StopWatch();

sw.start();

//위애 애노테이션 달려있는 메소드 실행

Object procced= joinPoint.proceed();



sw.stop();

logger.info(sw.prettyPrint());



return procced;

}

}

 

같은 로직인데 여러 군데 들어간다면 AOP를 활용하는 게 좋다.

애노테이션을 쓰지 않는 방법도 있다.

여러 가지방법과 사용방법이 존재한다.

'개발 소발 > 개발 Spring' 카테고리의 다른 글

Spring Scope란?  (0) 2020.07.13
Spring Autowired와 ComponentScan이란  (0) 2020.07.10
Spring IoC(Inversion of Control),Bean,의존성주입이란?  (0) 2020.07.08
프레임워크 개념  (0) 2018.01.26
SpringMVC란?  (0) 2018.01.11

IOC 

Inversion of Control

제어권이 뒤바뀐다.

원래는 자기가 사용할 의존성은 자기가 만들어 사용한다.

Ex) new로 생성해서 사용하는 것

 

Ioc는 사용하지만 만들지 않는다. 즉 누군가가 생성해준다.

누군가란? 스프링

Ex) new를 사용하지 않는다.

 

의존성 주입 예제

 

스프링에서 의존성을 주입해준다.(생성자 방식)

private final OwnerRepository owners;
public OwnerController(OwnerRepository clinicService, VisitRepository visits) { 
	this.owners = clinicService; 
    //vistis 는 생략 this.visits = visits;
}

 

만약 IoC가 적용 안되었다면?

이런 식으로 사용하면 원래 Null point Exception 에러가 난다.

 

Spring이 관리하는 객체를 Bean이라고 함.

즉, 스프링이 빈 객체를 생성해 주입해줘서 동작되게 한다.

 

결론 : IoC에서 객체 생성은 내가 하는 것이 아닌 스프링이 필요한 의존성을 주입해준다. 

 

IOC 컨테이너(Bean Factory) ApplicationContext

Bean Factory이 IOC 컨테이너인데 ApplicationContext는 BeanFactory를 상속받는다.

 

IOC컨테이너 역할

bean 생성하고 bean들 사이에 의존성을 엮어주고 스프링에 제공해준다.

 

OwnerController, OwnerRepository 등 즉 컨트롤러, 레파지토리 등은 빈으로 등록해 사용한다.

 

모든 클래스가 다 무조건 bean으로 등록되는 것이 아니다.

 

@Controller 등

@으로 등록하는 방식,

extends Repository 상속하는 방식,

@Bean으로 등록하는 방식 등

여러 가지 방법으로 Bean으로 설정이 가능하다.

 

의존성 주입은 bean끼리만 사용한다. 예외의 경우 다른 객체에 할 수 있지만 거의 하지 않는다.

즉, 주로 IOC컨테이너 안에 있는 객체에만 서로 의존성 주입을 한다.

 

IOC컨테이너는 매번 새로 객체를 생성하는 것이 아니라 생성된 객체를 같이 사용한다.

 

Bean

IoC 컨테이너가 관리하는 객체를 말한다. 

ApplicationContext가 만들어서 그 안에 담고 있는 객체를 말한다.

Component Scannig

-@Controller

-@Service

-@Repository

-@Component

등 여러 가지 등을 찾아서 bean으로 등록한다.

 

ex)

public interface OwnerRepository extends Repository<Owner, Integer>

Repository를 보면 특정한 @이 없더라도 특정 인터페이스를 상속받는 클래스를 찾아서 

내부에서 인터페이스를 구현하고 Bean으로 등록한다.

 

직적 Bean으로 등록

@Configuration과 @Bean으로 등록할 수 있다.

@Configuration(proxyBeanMethods = false)

@EnableCaching

class CacheConfiguration {



@Bean

public JCacheManagerCustomizer petclinicCacheConfigurationCustomizer() {

return cm -> {

cm.createCache("vets", cacheConfiguration());

};

}

}

 

 

@Autowried로 IoC컨테이너에서 객체를 꺼내 사용할 수 있다.

 

 

의존성 주입(Dependency Injection)

 

@Autowried로 보통 주입을 한다.

생성자

스프링 4.3부터 이상부턴 생성자에서 생략하고 사용할 수 있다.

public OwnerController(OwnerRepository clinicService, VisitRepository visits) {

this.owners = clinicService;

this.visits = visits;

}

,

필드

@Autowired

private final OwnerRepository owners;

, set

public void setOwners(OwnerRepository r){

this.owners = r;

}

등으로 주입할 수 있다.

 

주의점 : final로 생성하면 무조건 생성하거나 생성자를 만들어야 한다.

 

 

생성자를 생성하자 않고 @Autowried로 생성자 주입도 가능하다. (자주 사용하는 방법)

bean으로 등록되어있지않으면 의존성주입은 불가능하다.

'개발 소발 > 개발 Spring' 카테고리의 다른 글

Spring Autowired와 ComponentScan이란  (0) 2020.07.10
AOP란? AOP 기초개념  (0) 2020.07.09
프레임워크 개념  (0) 2018.01.26
SpringMVC란?  (0) 2018.01.11
MVC패턴이란?  (0) 2018.01.11

프레임워크 개념


1.sw 재사용성

2.디자인패턴 프레임워크란? 둘의 관련성

3.프레임워크 구성요소 종류


재사용 방법

copy & paste

가장 기본적인 방법이다.

ex)날짜 형태 지정 java

a클래스에 있는 코드를  b클래스에서 사용하기위해 복사 붙여넣기한다.

문제점- jdk가 바뀐다면? 코드가 있는 모든 클래스에 영향이가게된다.


method function(메소드호출)

a클래스에있던 코드를 메소드를 생성하여 집어넣는다.

클래스이름.메소드로 사용가능하다.

(호출하는쪽에는 영향이안감)


문제점 - MethodSignature(메소드명, 리턴타입, 아큐먼트 갯수,타입등)

복사 붙여넣기보단 진보된 방식이지만 작업영역간 결합도 문제 존재한다.


Class

메소드를 클래스 내부에 구현해서 만들어놓은것이다.

메소드를 구성해놓은 클래스를 상속한다.

자식 클래스에서 사용한다.

메서드방식보단 개선된 방식이다.


문제점 - signature 문제는 그대로있다.


AoP(관심의 분리)

- OOP를 supprt해주는 개념

- C에서도 사용가능

*관심사 분리

주제:은행

횡단관심모듈(기능적 로직)

ex)보안,로깅

핵심관심모듈(비지니스로직)

ex)계좌이체,입출금,이자계산

위빙 : 핵심관심모듈에서 횡단관심모듈을 직접 호출하지 않음(프레임워크에서 해줌)


AoP란?(간단설명)

간단하게말해, 계좌이체를 하게될때 로그를 남기게되는데 

코드상에서 직접호출하지 않고 프레임워크에서 처리해준다.







디자인패턴과 프레임워크의 관련성

디자인패턴의 정의

프로그램개발에서 자주 나타나는 과제를 해결하기 위한 방법 중 하나이다.

개발과정에 발견된 Know_how를 축적하여 이름붙인다.

재사용하기 쉽게 특정 규약을 묶어서 정리한것.

대표적인 디자인패턴(GOF)에서 23가지 지원한다.


디자인패턴 사용하는 이유

- 요구사항 변경에따른 소스코드변경 최소화

- 팀 프로젝트시 범용적인 코딩 스타일적용

- 인수인계시 직관적인 코드 사용


프레임워크의 정의

- 비기능적(Non-Funtional) 요구사항(성능,보안,로깅,확장성,안정성등)을 만족하는 구조와

구현된 기능을 안정적으로 실행하도록 제어해주는 잘만들어진 구조의 라이브러리 덩어리

또 애플리케이션들의 최소한의 공통점을 찾아 하부 구조를 제공함.

- 개발자들이 시스템 하부구조 구현하는데 들어갈 노력을 절감해준다.


프레임워크를 사용하는이유

비기능적인 요소(보안,로깅) 초기개발단계마다 구현해야하는 불합리함 극복할수있다.

- 기능적인 요구에만 집중(비지니스로직)하면된다.

- 반복적으로 발견되는 문제를 해결하기위한 특화된 Solution이다.



디자인패턴과 프레임워크의 관련성

- 디자인패턴은 프레임워크의 핵심적인 특징(프레임워크내부에 디자인패턴 적용해서 사용)이 있다.

- 프레임워크를 디자인패턴이라고는 하지못함. 디자인패턴을 사용하고있는 것이다.

- 프레임워크는 디자인 패턴과함께 패턴이 적용된 라이브러리를 제공한다.


프레임워크가 내부적으로 디자인패턴사용한다.

프레임워크를 사용하면 녹아들어가있는 디자인패턴을 사용하게된다.






프레임워크의 구성요소와 종류

Ioc(제어의 역전)

ClassLibrary

Design Patterm


IOC(제어의 역전)

- 인스턴스 생성 부터 소멸이 컨테이너가 처리(개발자가 안함)한다.

- 프레임워크한테 권한을 넘김으로써 개발자 코드가 신경쓸 부분을 줄여준다.

차이점


프레임워크(IOC적용) 사용할때

 라이브러리 사용할때

 프레임워크가 개발자가 작성한 코드를 호출

 개발자가 라이브러리 호출(스트링유틸사용시)


주도권이 프레임워크가 가지고있음(제어의 역전)

Spring 컨테이너가 IOC지원함.

-메타데이터(XML설정)를 통해 beans를 관리하고 어플리케이션의 중요부분을 형상한다.

bean들을 의존성 주입을 통해IoC지원한다.


ClassLibrary

특정 부분의 기술적인 구현을 라이브러리 형태로 제공(반제품) 기본적인 뒷단을 구성되어있다.

프레임워크코드가 유저코드를 호출(이게 제어역전)한다.





디자인패턴

디자인 패턴 + 라이브러리 = 프레임워크

프레임워크 사용시 라이브러리의 디자인패턴을 보면 구성을 이해하기쉽다.

커스터마이징할때도 디자인패턴의 이해가 필요하다.


'개발 소발 > 개발 Spring' 카테고리의 다른 글

AOP란? AOP 기초개념  (0) 2020.07.09
Spring IoC(Inversion of Control),Bean,의존성주입이란?  (0) 2020.07.08
SpringMVC란?  (0) 2018.01.11
MVC패턴이란?  (0) 2018.01.11
Mybatis Mapper 인터페이스란?  (0) 2018.01.11

+ Recent posts