728x90
반응형

추상클래스란?

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(){
      ...
   }
   ...
}
728x90
반응형
728x90
반응형

1. Class 

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

 

2. Object 

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

 

3. Instance

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

 

 

 

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

728x90
반응형

'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
728x90
반응형

작성일자 : 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

 

 

728x90
반응형

'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
728x90
반응형

작성일자 : 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");
    }
}
728x90
반응형

'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
728x90
반응형

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());

 

728x90
반응형

'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
728x90
반응형

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

 

 

 

 

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]

 

 

 

728x90
반응형

'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
728x90
반응형

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") )

- 캐시 된 데이터 존재

 

 

728x90
반응형

'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
728x90
반응형

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);
}

728x90
반응형

'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
728x90
반응형

[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. 확인

 

대상 접근

로그 확인

 

 

728x90
반응형

'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
728x90
반응형

[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 폴더 위치 설정

}

 

 

728x90
반응형

'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