클리어링의 잡화점

Spring Scheduler 정리 (Spring Scheduler, Quartz)

Clearing — Mon, 13 Feb 2023 12:05:23 +0900

스케쥴러(Scheduler)란?
특정한 시간에 등록한 작업을 자동으로 실행시키는 것

spring에서 scheduler는 대표적으로 2가지 방식을 제공한다. Spring Scheduler와 Quartz

Spring Scheduler
Spring Framework에서 기본으로 제공하는 Scheduler로 추가적인 의존(dependency) 설정이 불필요하다
@Component와 @Scheduled 어노테이션을 이용하여 사용이 쉽다.
기본적으로 1개의 Thread를 사용하여 동기 형식으로 진행 (@EnableAsync를 이용하여 비동기 형식으로도 사용 가능)

@Slf4j
@Component
@RequiredArgsConstructor
public class testScheduler {

    private final Job job;

    private final JobLauncher jobLauncher;

//    @Scheduled(cron = "${cron}")
    @Scheduled(cron = "0/10 * * * * *")
    public void testJob() {

        try {
            jobLauncher.run(job,
                    new JobParametersBuilder()
                            .addString("datetime",
                                    LocalDateTime.now().toString())
                            .toJobParameters()
            );
        } catch (JobExecutionAlreadyRunningException e) {
            log.error("DAILY_DATA JobExecutionAlreadyRunningException: {}", e.getMessage());
            throw new RuntimeException(e);
        } catch (JobRestartException e) {
            log.error("DAILY_DATA JobRestartException: {}", e.getMessage());
            throw new RuntimeException(e);
        } catch (JobInstanceAlreadyCompleteException e) {
            log.error("DAILY_DATA JobInstanceAlreadyCompleteException: {}", e.getMessage());
            throw new RuntimeException(e);
        } catch (JobParametersInvalidException e) {
            log.error("DAILY_DATA JobParametersInvalidException: {}", e.getMessage());
            throw new RuntimeException(e);
        }

    }

}

Quartz
Quartz는 Spring에서 기본으로 제공해주지 않기 때문에 라이브러리 의존(dependency) 설정이 필요
(implementation "org.springframework.boot:spring-boot-starter-quartz")
cron 표현식만 사용 가능하다 (fixedDelay 타입을 보장하지 않아 추가 작업 필요)

상대적으로 사용법이 어렵다.

Quartz 사용 이유
메모리 기반의 스케줄러뿐만이 아닌 DB 기반의 스케줄러 지원하기 때문에 다중 서버 간 스케줄링이 가능
즉, DB를 기반으로 클러스터링(Clustering) 기능을 제공

고가용성 (High Availability)
한 서버가 셧다운 되더라도 다른 서버에 의해 Job이 실행되어 다운 타임이 없음

확장성 (Scalability)
Quartz 설정된 서버를 구동하면 자동으로 DB에 스케줄 인스턴스로 등록된다
셧다운 된 서버는 다른 서버에 의해서 DB에서 삭제된다

로드 밸런싱 (Load balancing)
Cluster 구성으로 여러 Job이 여러 서버에 분산되어 실행된다
단, Quartz에서는 최소한의 구현으로 random 알고리즘만을 제공한다

Quartz 사용 용어

JobDataMap - 스케쥴러에서 job이 실행될 때 사용할 변수 값을 전달하는데 사용

JobDetail - job을 실행시키기 위한 정보를 담고있는 객체(이름, 그룹, jobDataMap 속성 등을 지정)
Trigger가 job을 수행 할 때 이 정보를 기반으로 실행

Trigger - job을 실행시킬 스케줄링 조건 (반복 횟수, 시간 등)
-> SimpleTrigger - 단순 반복 횟수와 실행등을 지정
CronTrigger - cron 표현식으로 Trigger를 정의

Listener - scheduler의 이벤트를 받을 수 있도록 Quartz에서 제공하는 인터페이스
-> JobListener - job 실행 전후로 이벤트를 받을 수 있음
TriggerListener - trigger가 발생하거나, 실패, 완료하였을 때 이벤트를 받을 수 있음

Spring batch + 스케쥴러 사용 예제

Clearing — Tue, 6 Dec 2022 19:58:20 +0900

출처) https://jojoldu.tistory.com/324?category=902551

1. Spring Batch 가이드 - 배치 어플리케이션이란?

Spring Batch In Action이 2011년 이후 개정판이 나오지도 않고 (2019.03 기준), 한글 번역판도 없고, 국내 Spring Batch 글 대부분이 튜토리얼이거나 공식 문서 중 일부분을 짧게 번역한 내용들이라 대용량 시

jojoldu.tistory.com

배치란 일괄처리라는 의미를 가지고 있으며 다음의 조건을 만족해야만 한다.

1) 대용량 데이터 - 배치 어플리케이션은 대량의 데이터를 가져오거나, 전달, 계산하는 등의 처리를 할 수 있어야 한다.

2) 자동화 - 배치 어플리케이션은 심각한 문제 해결을 제외하고는 사용자 개입 없이 실행되어야 한다.

3) 견고성 - 배치 어플리케이션은 잘못된 데이터를 충돌/중단 없이 처리할 수 있어야 한다.

4) 신뢰성 - 배치 어플리케이션은 무엇이 잘못되었는지를 추적할 수 있어야 한다. (로깅, 알림)

5) 성능 - 배치 어플리케이션은 지정한 시간 안에 처리를 완료하거나 동시에 실행되는 다른 어플리케이션을 방해하지

않도록 수행되어야 한다.

Job

-> 배치 처리 과정을 하나의 단위로 만들어 표현한 객체이고 여러 Step 인스턴스를 포함하는 컨테이너

Step

-> 실질적인 배치 처리를 저의 하고 제어하는데 필요한 모든 정보가 있는 도메인 객체

Tasklet

-> Step안에서 수행될 비즈니스 로직 전략의 인터페이스

jobInstance

-> job의 실행 단위이며, job 실행 시 하나의 instance가 생성
실패하여 재 실행할 경우 해당 instance에 관련된 데이터만 처리

jobParameters

-> jobInstance에 전달되는 매개변수로 jobInstance를 구분하는 객체로 사용

JobLauncher

-> job과 jobParameters를 사용하여 job을 실행하는 객체

Execution

-> jopExecution, stepExecution이 있으며 실행 시도에 대한 객체를 나타내며
상태,시작시간, 종료시간, 생성시간 등의 정보를 담고 있다.

Quartz는 스케줄러의 역할이지, Batch와 같이 대용량 데이터 배치 처리에 대한 기능을 지원하지 않는다.
반대로 Batch 역시 Quartz의 다양한 스케줄 기능을 지원하지 않아서 보통은 Quartz + Batch를 조합해서 사용한다.
정해진 스케줄마다 Quartz가 Spring Batch를 실행하는 구조라고 볼 수 있다.

build.gradle에 dependency 추가

dependencies {
   implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
   implementation 'org.springframework.boot:spring-boot-starter-batch'
   implementation 'org.springframework.boot:spring-boot-starter-quartz'
   compileOnly 'org.projectlombok:lombok'
   runtimeOnly 'org.mariadb.jdbc:mariadb-java-client'
   annotationProcessor 'org.projectlombok:lombok'

   testImplementation 'org.springframework.boot:spring-boot-starter-test'
   testImplementation 'org.springframework.batch:spring-batch-test'

   annotationProcessor 'org.projectlombok:lombok'
   testAnnotationProcessor 'org.projectlombok:lombok'
}

resources 폴더 하위 application.yml에 설정

spring:
  datasource:
    driver-class-name: org.mariadb.jdbc.Driver
    url: jdbc:mariadb://localhost:3306/test
    username: root
    password: 1234

  batch:
    jdbc:
      initialize-schema: "always"

      batch.job.enabled: false # CommandLineRunner 설정 해제 // 스케줄러를 사용하기 떄문에 구동시 동작 해제

  jpa:
    hibernate:
      ddl-auto: create

Job과 Step을 구성하는 Config

package com.example.batch.jobs;

...

@Configuration
@RequiredArgsConstructor
@Transactional
public class TutorialConfig {

    @Autowired
    @Qualifier("JpaUserRepository")
    UserRepository userRepository;

    private final JobBuilderFactory jobBuilderFactory; // Job 빌더 생성용
    private final StepBuilderFactory stepBuilderFactory; // Step 빌더 생성용

    // JobBuilderFactory를 통해서 tutorialJob을 생성
    @Bean
    public Job tutorialJob() {
        return jobBuilderFactory.get("tutorialJob")
                .start(tutorialStep())  // Step 설정
                .build();
    }

    // StepBuilderFactory를 통해서 tutorialStep을 생성
    @Bean
    public Step tutorialStep() {

        return stepBuilderFactory.get("tutorialStep")
                .tasklet(new TutorialTasklet(userRepository)) // Tasklet 설정
                .build();
    }
}

tasklet으로 step을 구성 -> 구성된 step으로 job을 구성

@RequiredArgsConstructor 어노테이션에 의해 생성자 주입

로직을 실행하는 Tasklet

package com.example.batch.tasklets;

...

@Slf4j
@RequiredArgsConstructor
public class TutorialTasklet implements Tasklet {


    final UserRepository userRepository;

    @Override
    public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
        log.info("executed tasklet !!");

        insertUser();

        return RepeatStatus.FINISHED;
    }

    public void insertUser(){
        UserEntity user = new UserEntity();
        user.setPw("1234");
        user.setName("1111");

        System.out.println(user);
        System.out.println(userRepository);

        userRepository.save(user);
    }
}

위에서 구성한 Batch를 실행하는 스케쥴러

package com.example.batch.schedulers;

...

import java.time.LocalDateTime;

@Component
@RequiredArgsConstructor
public class TutorialScheduler {

    private final Job job;  // tutorialJob
    private final JobLauncher jobLauncher;

    // 5초마다 실행
    @Scheduled(fixedDelay = 5 * 1000L)
    public void executeJob () {
        try {
            jobLauncher.run(
                    job,
                    new JobParametersBuilder()
                            .addString("datetime", LocalDateTime.now().toString())
                            .toJobParameters()  // job parameter 설정
            );
        } catch (JobExecutionException ex) {
            System.out.println(ex.getMessage());
            ex.printStackTrace();
        }
    }

}

스프링 부트 - JPA 연동

Clearing — Mon, 5 Dec 2022 09:25:46 +0900

build.gradle에 dependency 추가

dependencies {
   implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
   implementation 'org.springframework.boot:spring-boot-starter-web'
   developmentOnly 'org.springframework.boot:spring-boot-devtools'
   runtimeOnly 'org.mariadb.jdbc:mariadb-java-client'
   testImplementation 'org.springframework.boot:spring-boot-starter-test'

   implementation 'javax.servlet:jstl'
   implementation 'org.apache.tomcat.embed:tomcat-embed-jasper'
}

resources 폴더 하위 application.properties에 설정

## MariaDB
spring.datasource.driver-class-name=org.mariadb.jdbc.Driver
spring.datasource.url=jdbc:mariadb://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=1234

server.port=8088

spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp

spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=none

spring.jpa.show-sql

-> console 창에 jpa의 sql문을 볼지 안 볼지 설정

spring.jpa.hibernate.ddl-auto

create: 기존테이블 삭제 후 다시 생성 (DROP + CREATE)
create-drop: create와 같으나 종료 시점에 테이블 DROP
update: 변경분만 반영(운영 DB에서는 사용하면 안 됨)
validate: 엔티티와 테이블이 정상 매핑되었는지만 확인
none: 사용하지 않음(사실상 없는 값이지만 관례상 none이라고 한다.)

users 테이블과 매핑할 UserEntity

package com.example.jpatest.entity;

import javax.persistence.*;

@Entity(name = "users")
public class UserEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="id")
    private Long id;
    @Column(name="pw")
    private String pw;
    @Column(name="name")
    private String name;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getPw() {
        return pw;
    }

    public void setPw(String pw) {
        this.pw = pw;
    }
    public String getName() {
        return name;
    }

    public void setName(String username) {
        this.name = username;
    }
}

UserRepository 인터페이스

package com.example.jpatest.repository;

import com.example.jpatest.entity.UserEntity;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Optional;

@Repository
public interface UserRepository {
    UserEntity save(UserEntity user);
    void delete(Long id);
    void update(UserEntity user);
    Optional<UserEntity> findById(Long id);
    Optional<UserEntity> findByName(String name);
    List<UserEntity> findAll();
}

JpaRepository<T, Id>를 상속받아 인터페이스를 구성하여 JpaRepository의 메서드를 그대로 사용하는 것도 가능

해당 Repository에서는 필요한 기능만을 커스텀하여 사용하기 위해 JpaRepository를 상속받지 않았다.

해당 인터페이스를 상속받는 JpaUserRepository

package com.example.jpatest.repository;

import com.example.jpatest.entity.UserEntity;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.repository.query.FluentQuery;
import org.springframework.stereotype.Component;

import javax.persistence.EntityManager;
import java.util.List;
import java.util.Optional;

@Component("JpaUserRepository")
public class JpaUserRepository implements UserRepository{

    private final EntityManager em;

    public JpaUserRepository(EntityManager em) {
        this.em = em;
    }

    @Override
    public UserEntity save(UserEntity user) {
        em.persist(user);
        return user;
    }

    @Override
    public void delete(Long id) {
        UserEntity user = em.find(UserEntity.class, id);
        em.remove(user);
    }

    @Override
    public void update(UserEntity user) {
        em.createQuery("update users u set u.name= :name where u.id= :id")
                .setParameter("name",user.getName())
                .setParameter("id",user.getId())
                .executeUpdate();
    }

    @Override
    public Optional<UserEntity> findById(Long id) {
        UserEntity user = em.find(UserEntity.class, id);
        return Optional.ofNullable(user);
    }

    @Override
    public Optional<UserEntity> findByName(String name) {
        List<UserEntity> result = em.createQuery("select u from users u where u.name= :name", UserEntity.class)
        .setParameter("name", name)
        .getResultList();

        return result.stream().findAny();
    }

    @Override
    public List<UserEntity> findAll() {
      List<UserEntity> result = em.createQuery("select u from users u", UserEntity.class)
                .getResultList();
        return result;
    }



}

EntitiyManager를 통해 쿼리문을 커스텀하여 사용

스프링 부트 - MyBatis 연동

Clearing — Sun, 4 Dec 2022 16:50:24 +0900

Gradle을 이용하여 빌드를 진행하기 때문에 그에 맞춰 필요한 설정을 해준다,

build.gradle에 dependency 추가

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-web'
	implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:2.2.2'
	runtimeOnly 'org.mariadb.jdbc:mariadb-java-client'
	providedRuntime 'org.springframework.boot:spring-boot-starter-tomcat'
	testImplementation 'org.springframework.boot:spring-boot-starter-test'

	implementation 'javax.servlet:jstl'
	implementation 'org.apache.tomcat.embed:tomcat-embed-jasper'
}

resources 폴더 하위 application.properties에도 설정을 진행한다.

## 사용할 포트번호
server.port=8088

spring.mvc.view.prefix=/WEB-INF/views/
spring.mvc.view.suffix=.jsp

## MariaDB
spring.datasource.driver-class-name=org.mariadb.jdbc.Driver
spring.datasource.url=jdbc:mariadb://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=1234

## mybatis
mybatis.mapper-locations=classpath:mybatis/mappings/*.xml
mybatis.type-aliases-package=com.example.demo.member

mybatis.mapper-locations=classpath:mybatis/mappings/*.xml

-> sql문을 작성하는 mapping 파일의 위치 설정

mybatis.type-aliases-package=com.example.demo.member

-> mapper에 작성할 파일의 이름이 길어지기 때문에 별칭 설정

member-mapping.xml 파일

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="MemberService">

	<insert id="insertMember">
		INSERT INTO MEMBER VALUES(#{mid},#{mpw},#{mname})
	</insert>
	
	<update id="updateMember">
		UPDATE MEMBER SET MNAME=#{mname} WHERE MID=#{mid}
	</update>
	
	<delete id="deleteMember">
		<![CDATA[
		DELETE FROM MEMBER WHERE MID=#{mid}
		]]>
	</delete>
	
	<select id="selectOneMember" resultType="MemberVO">
		SELECT * FROM MEMBER WHERE MID=#{mid}
	</select>
	
 
	<select id="selectAllBoard" resultType="MemberVO">
		SELECT * FROM MEMBER
	</select>


</mapper>

mapper namespace = 해당 파일을 MemberService라 명명

mapper namespace의 MemberService 앞에 별칭으로 설정해 놓은 com.example.demo.member가 생략되어 있다.

member-mapping.xml(MemberService) 파일을 사용하는 memberDAO

package com.example.demo.member.impl;

import com.example.demo.member.MemberVO;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository("memberDAO")
public class MemberDAO {

    @Autowired
    private SqlSessionTemplate mybatis;

    public void insertMember(MemberVO vo) {
        System.out.println("회원가입 로그");
        mybatis.insert("MemberService.insertMember", vo);
    }

    void updateMember(MemberVO vo) {

        mybatis.update("MemberService.updateMember", vo);
    }

    void deleteMember(MemberVO vo) {

        mybatis.delete("MemberService.deleteMember", vo);
    }

    MemberVO selectOneMember(MemberVO vo) {

        return mybatis.selectOne("MemberService.selectOneMember", vo);
    }

    public List<MemberVO> selectAllMember(MemberVO vo) {

        return mybatis.selectList("MemberService.selectAllMember", vo);
    }
}

메서드 내의 인자 값은 namespace에 명명한 이름과 일치하여야 한다.

MemberService 인터페이스에 @Mapper 설정

@Mapper
public interface MemberService {
    void insertMember(MemberVO vo);
    void deleteMember(MemberVO vo);
    void updateMember(MemberVO vo);
    MemberVO selectOneMember(MemberVO vo);
    List<MemberVO> selectAllMember(MemberVO vo);
}

해당 인터페이스를 상속받는 ServiceImpl

package com.example.demo.member.impl;

import com.example.demo.member.MemberService;
import com.example.demo.member.MemberVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service("memberServiceImpl")
public class MemberServiceImpl implements MemberService {

    @Autowired
    private MemberDAO memberDAO;

    @Override
    public void insertMember(MemberVO vo) {
        memberDAO.insertMember(vo);
    }

    @Override
    public void deleteMember(MemberVO vo) {
        memberDAO.deleteMember(vo);
    }

    @Override
    public void updateMember(MemberVO vo) {
        memberDAO.updateMember(vo);
    }

    @Override
    public MemberVO selectOneMember(MemberVO vo) {
        return memberDAO.selectOneMember(vo);
    }

    @Override
    public List<MemberVO> selectAllMember(MemberVO vo) {
        return memberDAO.selectAllMember(vo);
    }

}

스프링 부트 - Validator 검증

Clearing — Wed, 26 Oct 2022 11:37:44 +0900

Validator는 사용자가 보낸 데이터에 대한 유효성 검사를 진행하는 것을 말한다.

이 유효성 검사는 두 단계로 진행하는 것이 보편적이다.

1. 클라이언트(브라우저, 사용자) : JS

2. 서버 : 파라미터 값을 검증

과거에는 이러한 검증방법이 회사마다 사용하는 곳마다 많이 달랐기 때문에 유지보수에 불리했지만

스프링에서는 Validator 인터페이스를 구현해놓았기 때문에 개발자들이 보다 일관된 코드를 작성할 수

있게 되었다.

사용자가 입력한 데이터를 확인하기 위한 Validator 예시

package com.kim.springboot;

import org.springframework.validation.Errors;
import org.springframework.validation.Validator;

// 유효성 검사 객체
public class DataValidator implements Validator{

	@Override
	public boolean supports(Class<?> clazz) {
		// TODO Auto-generated method stub
		return false;
	}

	@Override
	public void validate(Object target, Errors errors) {
		// Object target : 사용자의 입력 값(커맨드 객체)을 검증하기 위해, 
		// 파라미터로 받을 수 있게 구현한 부분
		// -> 디자인 패턴을 활용한 예: 부모에게 자식을 대입 가능
		DataDTO dto = (DataDTO)target;
		
		// 커맨드 객체에 저장된 값을 추출
		String writer = dto.getWriter();
		if(writer==null || writer.trim().isEmpty()) { 
		// ★ null 체크 순서 유의 !! null 이면 isEmpty가 실행이 안됨
			System.out.println("로그: DataValidator: validate 메서드: 작성자 null or empty");
			errors.rejectValue("writer", "error");
		}
		
		String content = dto.getContent();
		if(content==null || content.trim().isEmpty()) { 
			System.out.println("로그: DataValidator: validate 메서드: 내용 null or empty");
			errors.rejectValue("content", "error");
		}
		
		
	}

}

Q. errors 객체에 에러 내용을 저장했는데, 별도의 return을 하지 않는다.

A. .validate()을 수행할 때에, errors 객체를 "참조 변수"로 활용하기 때문이다
-> 모델 객체

Validator를 사용하는 컨트롤러

package com.kim.springboot;

import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class TestController {
	
	@RequestMapping("/")
	public @ResponseBody String root() {
		return "Validator 실습";
	}
	
	@RequestMapping("/insertPage")
	public String insertPage() {
		return "insertPage";
	}
	
	@RequestMapping("/insert")
	public String insert(@ModelAttribute("dto")DataDTO dto, BindingResult result) {
		// 데이터 유지를 위해 @ModelAttribute 사용
		String viewName = "boardPage";
		
		System.out.println("로그: TestController: insert 메서드: dto: "+dto);
		DataValidator validator= new DataValidator();
		validator.validate(dto, result); // result는 참조변수 ★
		if(result.hasErrors()) { // 에러가 발견되었다면,
			viewName="insertPage";
		}
		
		return viewName;
	}
	
}

사용자의 입력을 받는 insertPage

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>

<form action="/insert" method="post">
	작성자: <input type="text" name="writer" value="${dto.writer}"> <br>
	내용: <input type="text" name="content" value="${dto.content}"> <br>
	<input type="submit" value="글 작성하기">
</form>

</body>
</html>

=====================================

결과 화면

insertPage

=====================================

/insert에 의해 이동된 boardPage

=====================================

Validator 조건에 의해 작성자나 내용이 null 또는 비어있다면 해당 페이지에 데이터를 유지한 채 이동

스프링 부트 - 의존 주입

Clearing — Tue, 25 Oct 2022 09:05:21 +0900

의존 주입은

1) new를 직접 수행해서 바로 사용 (강한 결합)

2) 미리 만들어진 객체를 할당받아서 사용 => DI 의존성 주입 (약한 결합)

- 객체를 생성해주며 라이프사이클(생명주기)을 관리하고 의존 주입을 해준다 == 컨테이너 -> IoC

유지보수 용이 == 낮은 결합도, 높은 응집도

[의존 주입 방법]

1) .xml

2) 자바 코드 작성

3) @

@을 이용한 의존 주입 예시 1

각각의 예시 클래스들은 미리 작성해 둠

package com.kim.springboot.test;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration // 스프링 컨테이너의 설정 파일 역할
public class Config {
	// 설정 파일
	
	@Bean // 객체화 공식
	public Leader leaderA() {
		// Setter 주입
		Leader leader1 = new Leader();
		leader1.setName("티모");
		leader1.setMember(new MemberA());
		return leader1;
	}
	
	@Bean(name="kim")
	public Leader leaderB() {
		return new Leader("아리",new MemberA());
	}
	
	@Bean
	public MemberA memberA() {
		return new MemberA();
	}
	
	@Bean
	public MemberB memberB() {
		return new MemberB();
	}
}

위의 설정 파일을 사용하는 메인 클래스

(@SpringBootApplication 사용 안 함)

package com.kim.springboot;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Configuration;

import com.kim.springboot.test.Config;
import com.kim.springboot.test.Leader;
import com.kim.springboot.test.Member;

//@SpringBootApplication
public class TestApplication {

	public static void main(String[] args) {
	//	SpringApplication.run(TestApplication.class, args);
		
		// 1. IoC 제공해줄 스프링 컨테이너 생성하기
		ApplicationContext ac = new AnnotationConfigApplicationContext(Config.class);
		// 싱글톤으로 객체 생성 및 관리됨
		
		// 2. @Bean 등록한 객체 사용해보기
		Leader leader1 = (Leader) ac.getBean("leaderA");
		leader1.hello();
		// @Configuration으로 해당 파일이 설정파일이라는것을 인식 생성되어 있는 클래스들을 Config파일에 설정 
		// -> @Bean으로 컨테이너에 의해 각 클래스들 객체화
		// -> Config 설정 파일에서 설정한 내용들이 ac에 주입 
		// -> ac에서 객체화된 leaderA를 가져와 leader1에 주입 
		
		Leader leader2 = (Leader) ac.getBean("kim");
		leader2.hello();
		//
		
		Member member = ac.getBean("memberB",Member.class);
		member.hello("main에서 작성");
		//
		
	}

}

ApplicationContext ac = new AnnotationConfigApplicationContext(???);
=> 디자인 패턴 중 하나의 예시

=====================================================================================

예시 2 설정 파일 대신 실행될 컨트롤러

package com.kim.springboot.test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class TestController {
	@Autowired
	Leader leader1;
	@Autowired
	Leader leader2;
	@Autowired
	@Qualifier("memberB")
	Member member;
	
	@RequestMapping("/")
	public @ResponseBody String root() {
		leader1.hello();
		leader1.setMember(member);
		leader1.hello();
		
		if(leader1 == leader2) {
			System.out.println("동일한 객체입니다.");
		}
		else {
			System.out.println("동일하지 않습니다.");
		}
		
		return "루트(표지) 페이지";
	}
}

@SpringBootApplication 사용

package com.kim.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Test02Application {

	public static void main(String[] args) {
		SpringApplication.run(Test02Application.class, args); // 내장된 톰캣 실행
		// 1. main 메서드 실행
		// 2. @SpringBootApplication의 영향으로 @ 스캔 및 등록
		// 3. 10번 라인에 의해 내장 톰캣 실행
		// 4. ApplicationContext 생성 == 스프링 컨테이너 실행
		//		-> URL로 요청 입력시 RequestMapping에 의해 작성한 메서드가 호출되는 방식
	}

}

- @SpringBootApplication
Bean(객체)들을 생성할 때, 싱글톤을 유지할 수 있도록 설정 및 관리
각각의 객체들이 생성되면 용이한 순간을 추측하여 메모리를 관리
.jar 파일들도 생성 및 설정 관리
@ 지정된 클래스를 스캔해서 Bean 등록 관리

스프링 부트 설치 및 시작

Clearing — Mon, 24 Oct 2022 14:50:11 +0900

스프링 부트를 사용하게 되면 XML이 아닌 @을 사용하여 빈(Bean) 등록을 위한 설정파일(.xml)이

불필요해지므로 자바 코드만 보고서도 전체 내용 파악이 가능하게 된다.

라이브러리 관리 또한 pom.xml이 아닌 그레이들(GRADLE)을 사용하게 되면 .xml 대신

간단한 설정파일을 사용할 수 있다.

즉, 부트를 사용하게 되면 @을 사용하여 과도한 xml 설정이 필요 없어져 분석을 용이하게 할 수 있으며

외부 와스(WAS) 없이 내장된 톰캣 서버 사용이 가능하다. 또한 스트링 부트 스타터가

스프링 라이브러리 관리를 위한 자동 설정을 제공해준다.

[스프링 부트 설치]
이클립스 추가 설치 or 사이트에서 직접 설치
https://spring.io/tools -> .jar 다운로드 확인 -> cmd .jar(==.zip) 압축해제
-> cmd창에서 설치위치로 이동 후 확인 ex) d: -> dir(해당 위치에 있는 파일 확인 가능)
-> java -jar spring-tool 후 탭키 누르면 자동완성
-> sts release에서 .exe 실행

[Spring Starter Project 설정]
Name 이름
Type 라이브러리 관리 도구
Package 패키징 형식 -> 내장 WAS인 톰캣 서버 사용 시 War 사용
Java Version 11이상
Group 그룹명 com.kim
Package 패키지명 com.kim.springboot

next - > spring web -> 우측 하단 100% 설치될 때까지 대기
=> 'spring web' Dependencies 주입

src/main/resources -> static 하위(정적파일) ex) html, css, js 등
src 하위 -> 동적파일 ex) jsp 등
build.gradle == pom.xml

내장된 톰캣 서버의 기본 포트 번호는 8080
오라클과 함께 사용하면 충돌 발생
-> application.properties에서 server.port=???로 설정 ex) 8088

크롤링 시 만나 에러 - NosuchElementException

Clearing — Fri, 21 Oct 2022 09:54:18 +0900

필터 구현 시 만난 에러 - ORA-00933

Clearing — Thu, 20 Oct 2022 09:53:11 +0900

찜하기 구현 시 만난 에러 - NullPointerException

Clearing — Wed, 19 Oct 2022 08:52:10 +0900