반응형

추상클래스란?

Abstract 로 선언되어 추상 메소드를 0개 이상 가지는 클래스

 

- 단독 사용이 불가능하고, 자식 클래스를 통해 상속하여 사용

- 상속 시 추상 메소드를 오버라이딩을 통해 정의해야함

- 추상 클래스의 기능을 이용하고 확장하는 용도

- 상속 및 확장을 추구

 

문법 예시

AbsctractClass

abstract class AbstractClass {
   ...
   abstract void abstractMethod();
   ...
}

 

SubClass

public class SubClass extends AbstractClass {
   ...
   @Override
   public void abstractMethod(){
      ...
   }
   ...
}

 

 

 

 

인터페이스란?

Interface 로 선언되어 추상 메소드를 0개 이상 가지는 명세

 

- 단독 사용이 불가능하고, 구현체 클래스를 통해 구현하여 사용

- 구현시 추상 메소드를 오버라이딩을 통해 정의해야함

- 인터페이스의 명세(메소드 구현)를 강제하는 용도 

- default method 를 통해 메소드를 미리 선언할 수 있음(JAVA8 이상)

- 다형성을 추구

 

문법 예시

Interface

public interface InterfaceExample {
   void interfaceMethod();
   
   default void defaultMethod(){
      ...
   }
}

 

ImplementClass

public ImplementClass implements InterfaceExample {
   ...
   @Override
   public void interfaceMethod(){
      ...
   }
   ...
}
반응형
반응형

1. Class 

자바에서의 프로그램 구성 단위로 하나 이상의 필드나, 메소드로 구성. 일종의 설계도

 

2. Object 

클래스를 사용하여 구현할 대상

 

3. Instance

클래스에 의해 실제로 구현된(메모리에 할당 된) 실체

 

 

 

: Class 에 의해 구현될 대상을 Object 라 부르고, 실제로 구현된 대상을 Instnace 라 부름

반응형

'Java > Basic' 카테고리의 다른 글

Servlet / Servlet Container(Web Container)  (0) 2021.03.06
String / StringBuffer / StringBuilder  (0) 2020.10.02
다형성 / 오버로딩 / 오버라이딩  (0) 2020.10.02
추상클래스 / 인터페이스  (0) 2020.09.30
반응형

작성일자 : 2020.07.23

환경 : SpringBoot 2.1.6

목표 : H2 를 이용하여 Database 설치 없이, In Memory DB 를 사용하도록 설정 

 

H2란?

자바 기반의 오픈소스 관계형 데이터 베이스 관리 시스템 (RDBMS)

H2DB는 서버(Server) 모드와 임베디드(Embedded) 모드의 인메모리 DB 기능 지원

 

 

1. 의존성 추가

 

In build.gradle

dependencies {
..
   implementation 'com.h2database:h2'
   implementation 'org.springframework.boot:spring-boot-starter-jdbc'
..
}

 

* 'spring-boot-starter-jdbc' or 'spring-boot-starter-data-jpa' 의존성을 추가하면 DataSource 구현체로 tomcat-jdbc을 제공
* H2 의존성을 추가하고 난 후, 설정 파일에 아무 설정이 되어 있지 않으면 스프링 부트는 자동적으로 H2 데이터베이스를 기본 데이터베이스로 사용

* spring-boot-starter-jdbc 의존성을 추가하면 DataSource, JdbcTemplate을 별다른 설정없이 주입하여 사용 가능(@Autowired 등)

 

 

 

2. Connection 확인

 

@Autowired
DataSource datasource

...

  Connection connection = dataSource.getConnection()
  System.out.println(connection.getMetaData().getURL());
  System.out.println(connection.getMetaData().getUserName());

 

 

* H2 DB는 기본으로 testdb DB 명과, SA 유저를 사용 (Password는 없음)

 

 

3. 기본 DB 데이터 추가 

 

@Autowired
DataSource dataSource;
...

  Connection connection = dataSource.getConnection();
  Statement statement = connection.createStatement();
  String sql1 = "CREATE TABLE TESTTABLE(ID INTEGER NOT NULL, VALUE VARCHAR(255), PRIMARY KEY (ID) )";
  statement.executeUpdate(sql1);

  String sql2 = "INSERT INTO TESTTABLE VALUES(1, 'value')";
  statement.execute(sql2);
   

 

 

 

4. H2-Console 확인

 

-  Console 설정 추가

 

In Application.properties

spring.h2.console.enabled=true
spring.h2.console.path=/h2-console

 

- 설정 Path 로 접근 ( 위 설정에선 /h2-console )

 

Connection 에서 확인한 URL, Name 입력 (기본값은 jdbc:h2:mem:testdb , SA )

 

 

- 데이터 확인 (1, 'value')

 

 

DB 설정 코드

DatabaseConfig.java

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;

@Component
public class DatabaseConfig implements ApplicationRunner {

    @Autowired
    DataSource dataSource;

    @Override
    public void run(ApplicationArguments args) throws SQLException {
        try(Connection connection = dataSource.getConnection()){
            System.out.println(connection.getMetaData().getURL());
            System.out.println(connection.getMetaData().getUserName());

            Statement statement = connection.createStatement();
            String sql = "CREATE TABLE TESTTABLE(ID INTEGER NOT NULL, VALUE VARCHAR(255), PRIMARY KEY (ID) )";
            statement.executeUpdate(sql);

            String sql2 = "INSERT INTO TESTTABLE VALUES(1, 'value')";
            statement.execute(sql2);
        } catch (Exception e){
            System.out.println(e);
        }
    }
}

 

 

 

* 주의

 

2020.07.23 기준으로 Spring Boot 프로젝트 생성 시 2.3.1 버전이 생성되는데, 이 버전에서는 H2 연동 시 기본 URL 값으로 testdb 가 아니라 Random 으로 생성됀다. ( 해당 글은 2.1.6 버전이 기준 )

 

이를 testdb 로 고정하기 위해서는 아래 config 추가

spring.datasource.generate-unique-name=false

 


reference

https://engkimbs.tistory.com/782

 

 

반응형

'Java' 카테고리의 다른 글

[MyBatis] List 형식 멤버 변수 조회  (0) 2021.02.12
[Spring] Web Cache 적용  (0) 2020.12.19
[Spring] App 구동 후 자동 작업 실행  (0) 2020.02.23
Stream Example  (0) 2020.01.05
리스트 순환 중 아이템 삭제  (0) 2019.12.08
반응형

작성일자 : 2020.02.23

목표 : Spring App 구동 후 특정 작업 실행

 

1. ApplicationRunner 사용 (Parameter 활용 가능)

package com.example.demo.test;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Component
public class RunAfterApplicationStart implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) {
        System.out.println("ApplicationRunner Example");
        System.out.println(Arrays.toString(args.getSourceArgs()));
    }
}

 

2. CommandLineRunner 사용 (Parameter 활용 가능)

package com.example.demo.test;

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import java.util.Arrays;

@Component
public class RunAfterApplicationStart implements CommandLineRunner {
    @Override
    public void run(String... args) {
        System.out.println("CommandLineRunner Example");
        System.out.println(Arrays.toString(args));
    }
}

 

3. EventListener 사용

package com.example.demo.test;

import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class RunAfterApplicationStart {
    @EventListener(ApplicationReadyEvent.class)
    public void test() {
        System.out.println("ApplicationReadyEventListener Example");
    }
}
반응형

'Java' 카테고리의 다른 글

[Spring] Web Cache 적용  (0) 2020.12.19
[SpringBoot] H2 연동  (0) 2020.07.21
Stream Example  (0) 2020.01.05
리스트 순환 중 아이템 삭제  (0) 2019.12.08
[Spring] Cache 적용  (0) 2019.09.28
반응형

Java8 Stream 활용 예

 

- List to Result

// 합계
integerList.stream().reduce(Integer::sum); // returnType Optional<Integer>
integerList.stream().reduce((a,b) -> a + b); // returnType Optional<Integer>
integerList.stream().reduce(0, Integer::sum); // returnType Integer
integerList.stream().reduce(0, (a,b) -> a + b); // returnType Integer

// 문자열 변환
stringList.stream().collect(Collectors.joining(",")); // {1,3,2,5,4} -> "1,3,2,5,4"

 

- Grouping

// 객체 내 특정 데이터를 기준으로, 또 다른 특정 데이터를 그룹핑
Map<String, List<Integer>> myVoIntegerMap =
	myVoList.stream().collect(Collectors.groupingBy(MyVo::getKeyString, Collectors.mapping(MyVo::getInteger, Collectors.toList())));

// 객체 내 특정 데이터를 기준으로, 객체 자체를 그룹핑
Map<String, List<MyVo>> myVoMap =
	myVoList.stream().collect(Collectors.groupingBy(MyVo::getKeyString));

// 두 개의 키를 기준으로 이중 Map 생성
Map<String, Map<String, MyVo>> myVoDoubleMap =
	myVoList.stream().collect(Collectors.groupingBy(MyVo::getId, Collectors.toMap(MyVo::getSubId, Function.identity())));

 

- Order By Item

// Normal (오름차순)
list.stream().sorted(Comparator.naturalOrder()).collect(Collectors.toList());
list.stream().sorted().collect(Collectors.toList());
list.stream().sorted((a,b) -> a.compareTo(b)).collect(Collectors.toList());

// Normal Reverse (내림차순)
list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
list.stream().sorted((a,b) -> b.compareTo(a)).collect(Collectors.toList());

// Custom Object
list.stream().sorted(Comparator.comparing(MyVo::getItem)).collect(Collectors.toList());

// Custom Object Reverse
list.stream().sorted(Comparator.comparing(MyVo::getItem, Comparator.reverseOrder())).collect(Collectors.toList());

// Multiple Sort
 list.stream().sorted(Comparator.comparing(MyVo::getItem1).thenComparing(MyVo::getItem2)).collect(Collectors.toList()).forEach(System.out::println);
      

 

- List to Map

Map<Integer, MyVo> myVoMap 
	= myVoList.stream().collect(Collectors.toMap(MyVo::getIndex, Function.identity()));
    
// 중복 제거
Map<Integer, MyVo> myVoMap 
    = myVoList.stream().collect(Collectors.toMap(MyVo::getIndex, Function.identity(), (oldValue, newValue) -> oldValue));

+ Function.indextity()는 현재 인자로 들어온 Item을 그대로 반환

 

- Map to List

List<MyVo> myVoList 
	= myVoMap.entrySet().stream().map(vo->vo.getValue()).collect(Collectors.toList());

 

반응형

'Java' 카테고리의 다른 글

[SpringBoot] H2 연동  (0) 2020.07.21
[Spring] App 구동 후 자동 작업 실행  (0) 2020.02.23
리스트 순환 중 아이템 삭제  (0) 2019.12.08
[Spring] Cache 적용  (0) 2019.09.28
Spring Boot + MySQL 연동  (0) 2019.09.14
반응형

리스트 순환 중 아이템 삭제 예시

 

 

 

 

List list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);

        System.out.println(list); // [1, 2, 3, 4]

        
        //        for(Integer integer : list ){
        //            System.out.println(integer);
        //            if(integer==2){
        //                list.remove(integer);
        //            }
        //        }
        //  ConcurrentModificationException 발생 !! 


        Iterator it = list.iterator();
        while(it.hasNext()){
            Integer integer = it.next();
            if (integer == 3) {
                it.remove();
            }
        }
        System.out.println(list); // [1, 2, 4]

        // Java 8 이상
        list.removeIf(integer -> integer == 2);
        System.out.println(list); // [1,4]

 

 

 

반응형

'Java' 카테고리의 다른 글

[Spring] App 구동 후 자동 작업 실행  (0) 2020.02.23
Stream Example  (0) 2020.01.05
[Spring] Cache 적용  (0) 2019.09.28
Spring Boot + MySQL 연동  (0) 2019.09.14
[spring boot] AOP 설정  (0) 2019.07.21
반응형

Cache 적용

 

작성일자 : 2019.09.28

환경 : Spring Boot 2.1.8

 

 

1. Cache 사용 설정

 

import org.springframework.cache.annotation.EnableCaching;

 

@SpringBootApplication
@EnableCaching
public class MybatistestApplication {
   public static void main(String[] args) {
      SpringApplication.run(MybatistestApplication.class, args);
   }
}

 

 

2. Cache 사용 대상 선언

 

  • @Cacheable: 캐시 채우기를 트리거합니다.

  • @CacheEvict: 캐시 제거를 트리거합니다.

  • @CachePut: 메소드 실행을 방해하지 않고 캐시를 업데이트합니다.

  • @Caching: 메소드에 적용 할 여러 캐시 조작을 재 그룹화합니다.

  • @CacheConfig: 클래스 수준에서 몇 가지 일반적인 캐시 관련 설정을 공유합니다.

 

import org.springframework.cache.annotation.Cacheable;

 

@Cacheable("CacheName")
public void method(){

   ... 

   ...

}

 

해당 설정 이후, 캐시 적용

 

 

3. 확인

 

*주의 : 같은 클래스 내의 캐시 적용 함수를 호출 시 캐시 기능 미적용 ( this.cacheMethod() 등 )

 

import org.springframework.cache.CacheManager;

 

public class MyClass {

        @RequestMapping("/cacheTest")
                public String cacheTest() {       
                      service.cacheMethod();  // Cache가 적용 된 함수 호출
                      return "test";
                }

}

 

@Cacheable("CacheName")
public String cacheMethod(){
         return "Test"
};

 

 

위와 같이 작성 후 cacheTest를 호출 하면 아래와 같이 진행

 

 

- 첫 접근 시

 

1. cacheTest 실행 

2. cacheMethod Cache 확인 ( 캐시 데이터 없음 )

3. cacheMethod 실행

4. cacheMethod 결과 값 캐싱

5. cacheMethod 결과 값 반환

5. cacheTest 결과 값 반환

 

 

- 이후 접근 시

 

1. cacheTest 실행 

2. cacheMethod Cache 확인 ( 캐시 데이터 존재 )

3. 캐시 데이터 반환 ( cacheMethod 미실행 )

 

 

캐싱 상황은 CacheManager를 통해 확인 가능

 

@Autowired 
CacheManager cacheManager;

 

 

첫 접근 시, 캐시 데이터 X

- Spring은 CacheManager로 ConcurrentMapCacheManager를 Default로 사용

 

 

이후 접근 시, 캐시 데이터 존재 확인

- 어노테이션 내 설정 아이디로 Key 생성 ( @Cacheable("CacheName") )

- 캐시 된 데이터 존재

 

 

반응형

'Java' 카테고리의 다른 글

Stream Example  (0) 2020.01.05
리스트 순환 중 아이템 삭제  (0) 2019.12.08
Spring Boot + MySQL 연동  (0) 2019.09.14
[spring boot] AOP 설정  (0) 2019.07.21
[Spring Boot-Vue] 프로젝트 빌드  (0) 2019.07.21
반응형

Spring Boot + MySQL 연동

 

작성일자 : 2019.09.14

환경 : Spring Boot 2.1 MySQL 5.7 + Gradle, MyBatis

 

 

1. 연동 

 

1.1 ) Dependency 추가

 

build.gradle

 

...

dependencies {

...

   compile("org.mybatis.spring.boot:mybatis-spring-boot-starter:1.3.2")
   compile("commons-dbcp:commons-dbcp:1.4")
   compile("mysql:mysql-connector-java:5.0.8")

...

}

 

 

1.2 ) Config

 

DBConfig.java

 

package com.example.demo;

import javax.sql.DataSource;

import org.apache.commons.dbcp.BasicDataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

@Configuration
public class DBConfig {

 

   @Bean
   public DataSource dataSource() {
      BasicDataSource dataSource = new BasicDataSource();

     

      // DB 정보 ( 환경에 맞게 수정 필요 )
      dataSource.setDriverClassName("com.mysql.jdbc.Driver");
      dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/rmsdb");  // jdbc:mysql://'domain':'port'/'DataBaseName'
      dataSource.setUsername("root"); // ID
      dataSource.setPassword("qweqweqwe"); // PW


      return dataSource;
   }

 

   @Bean
   public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
      SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
      sqlSessionFactory.setDataSource(dataSource);


      sqlSessionFactory.setMapperLocations(
         new PathMatchingResourcePatternResolver().getResources("classpath*:com/example/demo/*.xml")
      ); // Mapper 위치 설정


      return (SqlSessionFactory)sqlSessionFactory.getObject();
   }

   @Bean
   public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
      return new SqlSessionTemplate(sqlSessionFactory);
   }


}

 

++

Mybatis는 SqlSession이라는 자바 인터페이스를 이용

SqlSessionFactory에서 SqlSession를 생성

SqlSessionTemplate은 SqlSession을 구현하고 코드에서 SqlSession를 대체하는 역할

 

 

1.3 ) 연동 확인

 

Test Controller 생성 후 설정한 Bean 정보 출력

 

package com.example.demo;

import java.sql.SQLException;
import javax.sql.DataSource;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class TestController {

   @Autowired
   DataSource dataSource;

   @Autowired
   SqlSessionFactory sqlSessionFactory;

   @Autowired
   SqlSessionTemplate sqlSessionTemplate;

   @RequestMapping("/check")
   public void test() throws SQLException {
      System.out.println(dataSource.getClass());
      System.out.println(sqlSessionFactory.getClass());
      System.out.println(sqlSessionTemplate.getClass());
      System.out.println(dataSource.getConnection());
   }
}

 

콘솔 확인

 

 

2. 기본 CRUD 세팅

 

MyBatis의 Mapper 연결 방식은

1. Mapper namespace를 직접 선언하여 연결하는 방식과

2. Mapper Interface를 활용하는 방식이 존재

 

해당 글에서는 Mapper namesapce를 직접 사용

 

 

TestDto.java

 

package com.example.demo;

 

public class TestDto {

 

        String id;

        String comment;

       

        public String getComment() {

               return comment;

        }

        public String getId() {

               return id;

        }

        public void setComment(String comment) {

               this.comment = comment;

        }

        public void setId(String id) {

               this.id = id;

        }

}

 

 

TestDao.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="com.example.demo.TestDao">

           <select id="selectList" resultType="com.example.demo.TestDto">

                     SELECT *

                     FROM

                                testtable

           </select>

          

           <select id="selectOne" parameterType="com.example.demo.TestDto" resultType="com.example.demo.TestDto">

                     SELECT *

                     FROM

                                testtable

                     WHERE

                                id = #{id}

           </select>

          

           <insert id="create" parameterType="com.example.demo.TestDto">

                     INSERT INTO testtable ()

                     VALUES (

                                #{id},

                                #{comment}

                     )

           </insert>

          

           <update id="update" parameterType="com.example.demo.TestDto">

                     UPDATE testtable

                     SET

                                comment = #{comment}

                     WHERE

                                id = #{id}

           </update>

          

           <delete id="delete" parameterType="com.example.demo.TestDto">

                     DELETE

                     FROM

                                testtable

                     WHERE

                                id = #{id}

           </delete>

          

</mapper>

 

SqlSessionFactory의 Mapper 설정 위치 아래에 생성

mapper에서의 namespace 및 id는 DAO에서 Parameter로 사용

 

 

TestDao.java

 

package com.example.demo;

 

import java.util.List;

 

import org.mybatis.spring.SqlSessionTemplate;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Repository;

 

@Repository("TestDao")

public class TestDao {

       

        @Autowired

        private SqlSessionTemplate sqlSessionTemplate;

       

        public List<TestDto> selectList(){

               return sqlSessionTemplate.selectList("com.example.demo.TestDao.selectList");

        };

 

        public TestDto selectOne(TestDto testDto){

               return sqlSessionTemplate.selectOne("com.example.demo.TestDao.selectOne",testDto);

        };

       

        public int create(TestDto testDto){

               return sqlSessionTemplate.insert("com.example.demo.TestDao.create",testDto);

        };

       

        public int update(TestDto testDto){

               return sqlSessionTemplate.update("com.example.demo.TestDao.update",testDto);

        };

       

        public int delete(TestDto testDto){

               return sqlSessionTemplate.delete("com.example.demo.TestDao.delete",testDto);

        };

}

 

 

 

TestController.java

 

package com.example.demo;

 

import java.sql.SQLException;

 

import javax.sql.DataSource;

 

import org.apache.ibatis.session.SqlSessionFactory;

import org.mybatis.spring.SqlSessionTemplate;

import org.springframework.beans.factory.annotation.Autowired;

 

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

 

@Controller

public class TestController {

       

        @Autowired

        DataSource dataSource;

 

        @Autowired

        SqlSessionFactory sqlSessionFactory;

       

        @Autowired

        SqlSessionTemplate sqlSessionTemplate;

       

 

        @Autowired

        TestDao testDao;

       

        @RequestMapping("/check")

        public String test() throws SQLException {

               System.out.println(dataSource.getClass());

               System.out.println(sqlSessionFactory.getClass());

               System.out.println(sqlSessionTemplate.getClass());

               System.out.println(dataSource.getConnection());

               return "test";

        }

       

        @RequestMapping("/1")

        public String create() {

               TestDto testDto = new TestDto();

               testDto.setId("1");

               testDto.setComment("Comment");

               testDao.create(testDto);

               return "create";

        }

       

        @RequestMapping("/2")

        public String read() {

               TestDto testDto = new TestDto();

               testDto.setId("1");

               System.out.println(testDao.selectList());

               System.out.println(testDao.selectOne(testDto));

               return "read";

        }

       

        @RequestMapping("/3")

        public String update() {

               TestDto testDto = new TestDto();

               testDto.setId("1");

               testDto.setComment("update");

               testDao.update(testDto);

               return "update";

        }

       

        @RequestMapping("/4")

        public String delete() {

               TestDto testDto = new TestDto();

               testDto.setId("1");

               testDao.delete(testDto);

               return "delete";

        }

}

 

 

 

 

DB Schema

 

CREATE TABLE `testtable` (
  `id` varchar(45) NOT NULL,
  `comment` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`id`)
)

 

 

---------

 

위 설정 후 Controller로의 URL 접근을 통해 CRUD 기능 동작 확인 가능

 

1. Create

 

 

 

2. Read

 

각각 List와 Obejct 형태

 

 

3. Update

 

 

4. Delete

 

 

Project 구조

 

 

-----------

++

Mapper Interface 활용 방식

 

in java

@Mapper
public interface MapperInterface {
   List selectList();
   TestDto selectOne(TestDto testDto);
   int create(TestDto testDto);
   int update(TestDto testDto);
   int delete(TestDto testDto);
}

 

 

In .xml

<mapper namespace="com.example.demo.MapperInterface">

   ...

</mapper>

이 경우 SqlSessionTemplate, SqlSessionFactory 설정은 필요 X

 

++

xml 없이 Mapper Interface에 SQL을 설정하는 방법도 있다

ex)

 

@Mapper
public interface MapperAnnotation {
   @Select("SELECT * FROM testtable")
   List selectList();

   @Select("SELECT * FROM testtable WHERE id = #{id}")
   TestDto selectOne(TestDto testDto);

   @Insert("INSERT INTO testtable () VALUES (#{id}, #{comment})")
   int create(TestDto testDto);

   @Update("UPDATE testtable SET comment = #{comment} WHERE id = #{id}")
   int update(TestDto testDto);

   @Delete("DELETE FROM testtable WHERE id = #{id}")
   int delete(TestDto testDto);
}

반응형

'Java' 카테고리의 다른 글

리스트 순환 중 아이템 삭제  (0) 2019.12.08
[Spring] Cache 적용  (0) 2019.09.28
[spring boot] AOP 설정  (0) 2019.07.21
[Spring Boot-Vue] 프로젝트 빌드  (0) 2019.07.21
[Spring Boot] JPA(Hibernate) 적용  (0) 2019.07.06
반응형

[spring boot] AOP 설정

 

작성일자 : 2019.07.21

환경 : Spring Boot 2.1.6, Gradle 3

 

 

추가 및 수정 파일

 

0. 기본 개념

 

1) 관점(Aspect)

구현하고자 하는 횡단 관심사의 기능, 한개 이상의 포인트컷과 어드바이스의 조합으로 만들어진다.

 

2) 조인포인트(Join point)

관점(Aspect)를 삽입하여 어드바이스가 적용될 수 있는 위치

 

3) 어드바이스(Advice)

관점(Aspect)의 구현체로 조인 포인트에 삽입되어 동작하는 코드 



 

1. AOP 의존성 추가

 

build.gradle

..

dependencies {

   ..

   compile('org.springframework.boot:spring-boot-starter-aop')

   ..

}

 

 

 

 

2. AOP 사용 설정

 

ProjectApplication.java

 

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@SpringBootApplication
@EnableAspectJAutoProxy // Enable AOP
public class AoptestApplication {
   public static void main(String[] args) {
      SpringApplication.run(AoptestApplication.class, args);
   }

}

 

 

 

3. AOP를 적용할 대상 구현

 

AopController.java

 

package com.example.demo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.web.bind.annotation.*;

@RestController
public class AopController {
    private static final Logger logger = LoggerFactory.getLogger(AopController.class);

    @GetMapping("/hello")
    public void hello(){
        logger.info("hello AOP");
    }

}

 

 

 

4. AOP 설정 파일 추가

 

AopConfig.java

 

package com.example.demo;

import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class AopConfig{
    private static final Logger logger = LoggerFactory.getLogger(AopConfig.class);

    @Before("execution(* com.example.demo.AopController.*(..))")
    public void doSomethingBefore() {
        logger.info("AOP Test : Before ");
    }

    @After("execution(* com.example.demo.AopController.*(..)) ")
    public void doSomethingAfter() {
        logger.info("AOP Test : After");
    }
}

 

적용 대상의 실행 전,후에 각각 aspect 동작하도록 설정

 

 

# Advice 종류

 

@Before : 조인포인트 전에 실행 
@AfterReturning : 조인포인트에서 성공적으로 리턴 된 후 실행
@AfterThrowing : 예외가 발생하였을 경우 실행
@After : 조인포인트에서 메서드의 실행결과에 상관없이 무조건 실행
@Around : 조인포인트의 전 과정(전, 후)에 수행

 

 

# execution 포인트컷 예

 

execution([수식어] [리턴타입] [클래스이름] [이름]([파라미터])

 

 

 

5. 확인

 

대상 접근

로그 확인

 

 

반응형

'Java' 카테고리의 다른 글

[Spring] Cache 적용  (0) 2019.09.28
Spring Boot + MySQL 연동  (0) 2019.09.14
[Spring Boot-Vue] 프로젝트 빌드  (0) 2019.07.21
[Spring Boot] JPA(Hibernate) 적용  (0) 2019.07.06
[Spring Boot] Eclipse 내 Lombok 설치  (0) 2019.07.05
반응형

[Spring Boot-Vue] 프로젝트 빌드

 

작성일자 : 2019.07.21

환경 : Vue 2.6.10, Vue-Cli 2/3, Spring Boot 2.1.6, npm 6.9.0, webpack 3.12.0

목표 : Spring Boot - Vue 구조의 프로젝트를 빌드하여 하나의 jar파일을 생성

 

0. Vue / Spring Project 세팅

 

- vue 버전 확인

npm list vue

 

- vue-cli 버전 확인

vue --version

 

- vue-cli에서 프로젝트 생성

vue cli 2.X :

  vue init webpack 'ProjectName' 

vue cli 3.X :

   vue create 'ProjectName'


1. vue 프로젝트 빌드

 

- 빌드할 대상은 vue-cli로 생성한 Default 프로젝트 ( 추가 설정 X )

 

 

Build 명령어

 

- vue cli 2.X :

%VueProjectRootPath% > npm run-script build

- vue cli 3.X :

%VueProjectRootPath% > npm run build

 

Default 설정 시 빌드 후 %VueProjectRootPath%\dist에서 빌드 결과물을 확인 가능

 

 

 

빌드 결과물을 %SpringBootProjectRootPath%\src\main\resources\static 밑으로 이동

 

 

해당 과정까지 진행 시 Spring Boot 서버 실행 후 /로 접근 시 vue 화면에 접근 가능

 

 

2. Spring Boot 빌드

 

빌드할 대상은 SpringBoot Default 프로젝트 ( 추가 설정 X )

 

Build 명령어

 

%SpringBootProjectRootPath%> gradlew build

 

 

Default 설정 시 빌드 후 %SpringBootProjectPath%\build\libs에서 빌드 결과물을 확인 가능

 

 

3. 확인

 

결과물 실행

 

%SpringBootProjectPath%\build\libs> java -jar buildtest-0.0.1-SNAPSHOT.jar

 

 

 

jar 파일 실행 후 / 접근 시 vue 기본화면 확인 가능

 

 

---

 

++

실행 시 java, javaw 명령어 차이

java는 cmd창에 콘솔로그가 찍히며 cmd 종료 시 프로세스 종료

javaw는 백그라운드로 실행 

 

++

Vue Project Build 결과물 경로 설정 방법

vue cli 3.X 으로 생성한 Vue Project 일 시

 

ROOT 밑에 vue.config.js 파일 추가

const path = require("path");

 

module.exports = {

  outputDir: path.resolve(__dirname"../src/main/resources/static"),

  //   assetsDir:  "./"  - asset 폴더 위치 설정

}

 

 

반응형

'Java' 카테고리의 다른 글

Spring Boot + MySQL 연동  (0) 2019.09.14
[spring boot] AOP 설정  (0) 2019.07.21
[Spring Boot] JPA(Hibernate) 적용  (0) 2019.07.06
[Spring Boot] Eclipse 내 Lombok 설치  (0) 2019.07.05
[Spring Boot] 개발 환경 세팅  (2) 2019.07.05

+ Recent posts