728x90
반응형
👩💻 자바 개발자 양성과정 53일차
- Hikari를 이용해서 DB에 연결하기
- iBatis를 이용해서 DB에 연결하기
- MyBatis를 이용해서 DB에 연결하기
- MySql제어하기
스프링관점 관점에서 Domain Model Class는 VO로 읽고,
Presentation는 controller라고 읽고,
service 는 그대로 service라고 읽는다.
Spring에서 DB 연결/제어하는 방식은 여러가지가 있다.
위 이미지에서 JDBC Interface는 DB에 접속하기 위한 셋팅인 셈이다.
실제로 DB에 연결하는건 JDBC드라이버가 하는것이다.
JDBC 인터페이스는 여러가지가 있다. (MySql을 컨트롤 하는 방법)
첫번째, Jdbc Template
두번째, ibatis
세번째, mybatis
Data Source는 여러가지가 있다.
첫째. SimpleDriverDataSource
풀링을 안한다.
둘째, SingleConnectionDriverDataSource
풀링을 한다.
셋째, HikariCP
넷째, DBCP2
💫 Hikari를 이용해서 DB에 연결하기 (Data Source) - Annotation방식
<dependency>
<groupId>com.zaxxer</groupId>
<artifactId>HikariCP</artifactId>
<version>5.0.0</version>
</dependency>
src/main/resource/beans.xml
db.driverClass=com.mysql.jdbc.jdbc2.optional.MysqlDataSource
db.url=jdbc:mysql://localhost:3306/test
db.username=root
db.password=1234
src/main/java > config > ApplicationConfig.java
package com.example.config;
import javax.sql.DataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.core.io.ClassPathResource;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
@Configuration
@ComponentScan(basePackages = {"com.example"})
public class ApplicationConfig {
@Value("${db.driverClass}")
private String driverClass;
@Value("${db.url}")
private String url;
@Value("${db.username}")
private String username;
@Value("${db.password}")
private String password;
//dbinfo.properties에서 값을 받아와서 위에 4개값을 셋팅한다.
//?? 위에 4개값을 셋팅한다. -> "위에 4개 값" 이걸 어떻게 말해주고 있는건지?
//new하지핞고 자동으로 셋팅함 PropertySources 인바이런트가 만들어지기 전에 빈이 만들어지기 전
//PropertySourcesPlaceholderConfigurer가 있기에 멤버변수에게 셋팅을 해준다
@Bean
public static PropertySourcesPlaceholderConfigurer configurer() {
PropertySourcesPlaceholderConfigurer configurer = new PropertySourcesPlaceholderConfigurer();
configurer.setLocation(new ClassPathResource("dbinfo.properties"));
return configurer;
}
//DataSource를 만든다.
@Bean
public DataSource dataSource() {
//HikariConfig 방식
HikariConfig config = new HikariConfig();
config.setJdbcUrl(url);
config.setUsername(username);
config.setPassword(password);
config.addDataSourceProperty("cachePrepStmts", "true");
config.addDataSourceProperty("prepStmtCacheSize", "250");
config.addDataSourceProperty("prepStmtCacheSqlLimit", "2048");
HikariDataSource ds = new HikariDataSource(config);
return ds;
//DriverManagerDataSource 방식
/*
* DriverManagerDataSource dataSource = new DriverManagerDataSource();
* dataSource.setDriverClassName(this.driverClass); dataSource.setUrl(this.url);
* dataSource.setUsername(this.username); dataSource.setPassword(this.password);
* return dataSource;
*/
}
}
src/main/java > test > MainClass.java
package com.example.test;
import java.sql.Connection;
import javax.sql.DataSource;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import com.example.config.ApplicationConfig;
import lombok.extern.java.Log;
@Log
public class MainClass {
public static void main(String[] args) {
// 환경정보를 ApplicationConfig에서 가져옴
ApplicationContext ctx = new AnnotationConfigApplicationContext(ApplicationConfig.class);
DataSource ds = (DataSource) ctx.getBean("dataSource");
//올바르게 접속되었는지 확인하기
try(Connection conn = ds.getConnection()){
log.info(ds.toString());
} catch (Exception e) {
log.info(e.toString());
}
}
}
💫 Hikari를 이용해서 DB에 연결하기 (Data Source) - xml방식
dbinfo.properties
db.driverClass=com.mysql.cj.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/test
db.username=root
db.password=1234
bean.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
<context:component-scan base-package="com.example" />
<context:property-placeholder location="classpath:dbinfo.properties" />
<!-- HikariCP 설정 Start-->
<bean id="hikariConfig" class="com.zaxxer.hikari.HikariConfig">
<property name="driverClassName" value="${db.driverClass}" />
<property name="jdbcUrl" value="${db.url}" />
<property name="username" value="${db.username}" />
<property name="password" value="${db.password}" />
</bean>
<bean id="dataSource"
class="com.zaxxer.hikari.HikariDataSource" destroy-method="close">
<constructor-arg name="configuration" ref="hikariConfig" />
</bean>
<!-- HikariCP 설정 End -->
<!-- mybatis-spring 설정 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="configLocation" value="classpath:mybatis-config.xml" />
<property name="mapperLocations">
<list>
<value>classpath:mybatis-mapper.xml</value>
</list>
</property>
</bean>
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg ref="sqlSessionFactory" />
</bean>
</beans>
💫 iBATIS를 이용해서 DB에 연결하기, MySql제어하기 (JDBC 인터페이스)
1. 메이븐 프로젝트로 만든다.
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>Membership</groupId>
<artifactId>Membership</artifactId>
<version>0.0.1-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.12</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.22</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.3.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.12</version>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>5.6.3</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.27</version>
</dependency>
<dependency>
<groupId>com.zaxxer</groupId>
<artifactId>HikariCP</artifactId>
<version>3.4.2</version>
</dependency>
<dependency>
<groupId>org.apache.ibatis</groupId>
<artifactId>ibatis-sqlmap</artifactId>
<version>2.3.4.726</version>
</dependency>
</dependencies>
</project>2. pom.xml 셋팅
3. pom.xml를 maven install해준다
4. java버전을 맞춰준다.
src/main/resource/dbinfo.properties
db.driverClass=com.mysql.jdbc.cj.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/test
db.username=root
db.password=1234
src/SqlMapConfig.xml
<?xml version="1.0" encoding="UTF-8"?>
<!-- iBATIS의 경우임, ApplicationConfig와 같은 용도임 -->
<!-- <!DOCTYPE [sqlMapConfig] 여기에 들어가는거로 해당 xml의 역활이 구분됨 -->
<!DOCTYPE sqlMapConfig
PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"
"http://ibatis.apache.org/dtd/sql-map-config-2.dtd">
<sqlMapConfig>
<properties resource="dbinfo.properties" />
<settings useStatementNamespaces="true" />
<transactionManager type="JDBC">
<!-- dataSource type="SIMPLE" 는 일반 JDBC인것임 -->
<dataSource type="SIMPLE">
<property name="JDBC.Driver" value="${db.driverClass}" />
<property name="JDBC.ConnectionURL" value="${db.url}" />
<property name="JDBC.Username" value="${db.username}" />
<property name="JDBC.Password" value="${db.password}" />
</dataSource>
</transactionManager>
<sqlMap resource="com/example/dao/Users.xml" />
</sqlMapConfig>
💫 MyBatis를 이용해서 DB에 연결하기, MySql제어하기
파랑색 - Spring에서 제공하는 애
주황색 - MyBatis에서 제공하는 애
pom.xml에 조건에 맞춰 2개 추가
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.7</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.6</version>
</dependency>
src/main/resource/dbinfo.properties
db.driverClass=com.mysql.cj.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/test
db.username=root
db.password=1234- DB환경 설정을 한다.
src/main/resource/mybatis-config.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<properties resource="dbinfo.properties" />
<typeAliases>
<typeAlias type="com.example.vo.UserVO" alias="userVO" />
</typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC" />
<dataSource type="POOLED">
<property name="driver" value="${db.driverClass}" />
<property name="url" value="${db.url}" />
<property name="username" value="${db.username}" />
<property name="password" value="${db.password}" />
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="com/example/dao/mybatis-mapper.xml" />
</mappers>
</configuration>- dbinfo.properties에서 DB환경정보를 가져와서 DataSource를 셋팅한다.
src/main/java/com.example.dao/mybatis-config.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.vo.UserVO">
<resultMap id="userVOResult" type="userVO">
<result property="userid" column="userid" />
<result property="name" column="name" />
<result property="gender" column="gender" />
<result property="city" column="city" />
</resultMap>
<!-- 자바에서 xml 로 넘어온거 property -->
<!-- xml에서 자바로 보내는거 result -->
<select id="select" parameterType="String" resultType="userVO"
resultMap="userVOResult">
SELECT * FROM USERS WHERE userid = #{userid}
</select>
<insert id="insert" parameterType="userVO">
INSERT INTO USERS(userid, name, gender, city)
VALUES (#{userid}, #{name}, #{gender}, #{city})
</insert>
</mapper>
src/main/java/com.example.dao/UserDaoImpliBatis.java
package com.example.dao;
import java.io.IOException;
import java.io.Reader;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.springframework.stereotype.Repository;
import com.example.vo.UserVO;
import com.ibatis.common.resources.Resources;
import lombok.extern.java.Log;
//서비스가 해당 Class를 부를때, UserDaoImpliBatis로 불러도 되는데, userDao로 부르게 하고 싶어서 @Repository를 적음
// class도 하나의 bean이라고 봄/ 굳이 bean이라고 부르는 이유는 containor가 관리하기에 저렇게 부르는거임
@Repository("userDao")
@Log
public class UserDaoImpliBatis implements UserDao {
@Override
public UserVO selectUser(String userid) {
Reader rd = null;
SqlSession session = null;
UserVO userVO = null;
try {
rd = Resources.getResourceAsReader("mybatis-config.xml");
session = new SqlSessionFactoryBuilder().build(rd).openSession();
userVO = (UserVO) session.selectOne("select", userid);
} catch (IOException e) {
e.printStackTrace();
}
return userVO;
}
@Override
public void insertUser(UserVO userVO) {
Reader rd = null;
SqlSession session = null;
try {
// SqlMapConfig.xml 을 reader형으로 바꿔줘
rd = Resources.getResourceAsReader("mybatis-config.xml");
// reader을 주고나면 buildSqlMapClient를 만들고
session = new SqlSessionFactoryBuilder().build(rd).openSession();
// select 일때는 selectOne이고, insert일때는 insert
session.insert("insert", userVO);
session.commit();
log.info(userVO.toString());
} catch (IOException e) {
e.printStackTrace();
session.rollback();
}
}
}SqlSessionFactoryBuilder -> SqlSessionFactory -> SqlSession
src/main/java/com.example.dao/UserServiceImpliBatis.java
package com.example.service;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.example.dao.UserDao;
import com.example.vo.UserVO;
@Repository("userService")
public class UserServiceImpliBatis implements UserService {
//UserDao와 바인딩
@Autowired
private UserDao userDao;
@Override
public UserVO selectOne(String userid) {
return this.userDao.selectUser(userid);
}
@Override
public void insert(UserVO userVo) {
this.userDao.insertUser(userVo);
}
}
src/test/java/com.example.test/UserBeanJUnitSpringTest.java
package com.example.test;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import com.example.service.UserService;
import com.example.vo.UserVO;
import lombok.extern.java.Log;
//junit test를 위한 코드임
@ExtendWith(SpringExtension.class)
//컴포넌트 스캔을 위해서 필요함 DB랑은 상관이 하나도 없음
@ContextConfiguration(locations = {"classpath:beans.xml"})
@Log
class UserBeanJUnitSpringTest {
//DataSource형을 바인딩 해온다.
@Autowired
private UserService userService;
//private DataSource dataSource;
@Test
void selectOne() {
//assertNotNull(this.dataSource);
UserVO userVO = this.userService.selectOne("jimin");
log.info(userVO.toString());
}
@Disabled @Test
void insert() {
UserVO userVO = new UserVO("sojin","소진","여자","경기도");
this.userService.insert(userVO);
}
}
src/main/resource/beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
<context:component-scan base-package="com.example" />
</beans>컴포넌트 스캔을 위해서 필요함 DB랑은 상관이 하나도 없음
💫 MyBatis를 이용해서 DB에 연결하기, MySql제어하기 - 2
다른점 : dao에서 중복되던 부분 @Autowired로 줄여쓸수 있음
dbinfo.properties
db.driverClass=com.mysql.cj.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/test
db.username=root
db.password=1234- DB환경 설정을 한다.
SqlMapConfig.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<typeAliases>
<typeAlias type="com.example.vo.CityVO" alias="cityVO" />
</typeAliases>
</configuration>- type을 추가한다.
- type "cityVO"는 com.example.vo 패키지에 cityVO 클래스를 칭한다.
mybatis-mapper.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="City">
<resultMap type="cityVO" id="cityVOReault">
<result property="id" javaType="int" column="ID" jdbcType="INTEGER" />
<result property="name" javaType="String" column="Name" jdbcType="CHAR" />
<result property="countryCode" javaType="String" column="CountryCode" jdbcType="CHAR" />
<result property="district" javaType="String" column="District" jdbcType="CHAR" />
<result property="population" javaType="int" column="Population" jdbcType="INTEGER" />
</resultMap>
<select id="selectOne" resultType="cityVO"
resultMap="cityVOReault" parameterType="String">
SELECT ID, Name, CountryCode, District, Population FROM city
WHERE Name = #{name}
</select>
</mapper>
- City라는 이름으로 mapping한다.
- cityVO타입을 반환할 ORM만든다.
- ORM이란? Object relation mapping: sql이랑 자바랑 연결하는 것이다. (그래서 sql 컬럼명과 데이터 타입을 함께 적는것이다)
- ORM를 하는 이유는 sql로 받아온 데이터를 cityVO타입으로 만들어야하기 때문이다.
이를 위해선 sqlmapper가 필요하다. 그 대표적인 방식이 mybatis이다.
- cityVOReault이라고 부를 ORM은 cictyVO타입으로 설정한다. 쉽게 리턴타입이라고 생각하면 편하다.
- 해당 map의 property는 id,name,country,district,population로 만들어져 있다. 이는 key를 의미한다.
위코드로 resultMap은 아래와 같이 만들어졌다.
| [resultMap] cityVOReault | ||
| property | javaType | |
| [KEY] id | int | [VALUE] |
| [KEY] name | String | [VALUE] |
| [KEY] country | String | [VALUE] |
| ... | ... | ... |
resultMap 하단 select태그는 sql에 select할때 사용한다.
insert일때는 insert태그를, delect일때는 delect태그를, update일때는 update태그를 입력하면된다. 쉽다.
원래는 java dao에 sql구문을 작성했는데, 해당 방식은 sql과 java를 분리할수 있다는 장점이 있다.
쿼리에 변수로 들어가야하는
태그에 들어가는 속성을 보자
property : java -> xml
result : xml -> java
| id="selectOne" | 해당 태그의 고유명을 "selectOne"라고 부른다. |
| resultType="cityVO" | 리턴타입은 cityVO라고 불리는 타입이다. |
| resultMap="cityVOReault" | 리턴맵은 바로 이전에 만든 "cityVOReault" 이다. |
| parameterType="String" | 파라미터 유형은 String이다. |
| statementType="PREPARED" | 쿼리에 파라미터(변수)가 들어가기 떄문에, statementType은 PREPARED이다. |
resultMap에 result property로 적은 것과 select에 userid를 의미하는 변수 부분이 같아야 하는지 헷갈릴 수 있다.
같을 필요는 없다. select태그에서 사용한 변수는 해당 select를 실행하는 dao쪽에서 보내는 파라미터명과 통일 시키기만 하면된다.
위에처럼 말이다.
하지만 실제 vo와 동일하게 써야하는 순간도 있는데, 그건 값을 vo로 받아왔을때다.
SqlSession에서 vo형식으로 insert했을 때는 해당 vo의 getter setter를 사용하기때문에 프로퍼티 이름을 정확하게 작성해야한다.
beans.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd">
<!-- auto와이어드 쓰려면 있어야 함 -->
<context:component-scan base-package="com.example"></context:component-scan>
<!-- 변수에 dbinfo.properties 내 값을 넣어서 dataSource를 만든다. -->
<context:property-placeholder
location="classpath:dbinfo.properties" />
<bean id="dataSource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource">
<property name="driverClass" value="${db.driverClass}" />
<property name="url" value="${db.url}" />
<property name="username" value="${db.username}" />
<property name="password" value="${db.password}" />
</bean>
<!-- mybatis-spring -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="configLocation" value="classpath:SqlMapConfig.xml" />
<property name="mapperLocations">
<list>
<value>classpath:mybatis-mapper.xml</value>
</list>
</property>
</bean>
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg ref="sqlSessionFactory" />
</bean>
</beans>
| sqlSession | ||||||||
sqlsessionfactory
|
CityDaoImpl.java
package com.example.dao;
import java.util.List;
import org.apache.ibatis.session.SqlSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.example.vo.CityVO;
@Repository("cityDao")
public class CityDaoImpl implements CityDao {
@Autowired
private SqlSession sqlSession;
@Override
public CityVO read(String name) {
// select랑 selectOne의 차이점은 selectOne은 한개임을 보장함
return this.sqlSession.selectOne("City.selectOne", name);
}
}
CityServiceImpl.java
package com.example.service;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import com.example.dao.CityDao;
import com.example.vo.CityVO;
@Repository("cityService")
public class CityServiceImpl implements CityService {
@Autowired
private CityDao cityDao;
@Override
public CityVO selectCity(String name) {
return cityDao.read(name);
}
}
CityDemoTest.java
package com.example.test;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import com.example.service.CityService;
import com.example.vo.CityVO;
import lombok.extern.java.Log;
//junit test를 위한 코드임
@ExtendWith(SpringExtension.class)
//컴포넌트 스캔을 위해서 필요함 DB랑은 상관이 하나도 없음
@ContextConfiguration(locations = {"classpath:beans.xml"})
@Log
class CityDemoTest {
@Autowired
private CityService cityService;
@Test
void test() {
CityVO city = this.cityService.selectCity("Semarang");
log.info(city.toString());
//assertNotNull(this.cityService);
}
}
@Autowired와 @Repesitory를 연결하기 위해선 아래 두개의 부분은 같아야 한다.
728x90
반응형