시퀄라이즈는 ORM(Object-relational Mapping)으로 분류가 된다.

ORM은 자바스크립트 객체와 데이터베이스의 릴레이션을 매핑해주는 도구이다.

 

1. express를 이용해서 새 프로젝트 생성

$ express sequlize_ex --view=pug

 

위에 나온대로 디렉토리를 바꿔준뒤 npm i를 해준다.

$ cd sequelize_ex
$ npm i

 

방금 만든 프로젝트에 sequelize와 mysql2 패키지를 설치한다. 그 후 sequelize 커맨드를 사용하기 위해 sequelize-cli를 전역 설치

$ npm i sequelize mysql2
$ npm i -g sequelize-cli
$ sequelize init

 

그 뒤 파일들을 아래대로 세팅

models/index.js

const path = require('path');
const Sequelize = require('sequelize'); //sequelize 연결

const env = process.env.NODE_ENV || 'development';
const config = require(path.join(__dirname, '..', 'config', 'config.json'))[env];
const db = {};

const sequelize = new Sequelize(config.database, config.username, config.password, config);


db.sequelize = sequelize;
db.Sequelize = Sequelize;

//user와 comment 테이블을 연결시킨다.
db.User = require('./user')(sequelize, Sequelize);
db.Comment = require('./comment')(sequelize, Sequelize); 

//테이블 간의 관계를 정의해줌
db.User.hasMany(db.Comment, {foreignKey: 'commenter', sourceKey: 'id'});
db.Comment.belongsTo(db.User, {foreignKey: 'commenter', targetKey: 'id'});

module.exports = db; //db라는 객체에 user와 comment 모델을 담는다.

 

시퀄라이즈를 통해 익스프레스 앱과 MYSQL을 연결한다. app.js에서 추가해준다.

app.js

var createError = require('http-errors');
var express = require('express');
var path = require('path');
var cookieParser = require('cookie-parser');
var logger = require('morgan');

var indexRouter = require('./routes/index');
var usersRouter = require('./routes/users');
var commentsRouter = require('./routes/comments');

//추가
var sequelize = require('./models').sequelize;

var app = express();

//추가
sequelize.sync();
// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'pug');

app.use(logger('dev'));
app.use(express.static(path.join(__dirname, 'public')));
app.use(express.json());
app.use(express.urlencoded({ extended: false }));
app.use(cookieParser());

app.use('/', indexRouter);
app.use('/users', usersRouter);
app.use('/comments', commentsRouter);

// catch 404 and forward to error handler
app.use(function(req, res, next) {
  next(createError(404));
});

// error handler
app.use(function(err, req, res, next) {
  // set locals, only providing error in development
  res.locals.message = err.message;
  res.locals.error = req.app.get('env') === 'development' ? err : {};

  // render the error page
  res.status(err.status || 500);
  res.render('error');
});

module.exports = app;

 

번거롭지만 MYSQL에서 정의한 테이블을 시퀄라이즈에서도 정의해야 한다.

기본적으로 모델 이름은 단수형으로 테이블 이름은 복수형으로 사용한다.

 

models/user.js

module.exports = (sequelize, DataTypes) => {
    return sequelize.define('user', {
        name: {
            type: DataTypes.STRING(20),
            allowNull: false,
            unique: true,
        },
        age: {
            type: DataTypes.INTEGER.UNSIGNED,
            allowNull: false,
        },
        married: {
            type: DataTypes.BOOLEAN,
            allowNull: false,
        },
        comment: {
            type: DataTypes.TEXT,
            allowNull: true,
        },
        created_at: {
            type: DataTypes.DATE,
            allowNull: false,
            defaultValue: DataTypes.NOW,
        },
    }, {
        timestamps: false,
    });
};

 알아서 id를 기본 키로 연결하므로 id 컬럼은 적어줄 필요가 없다.

그리고 알아둘 것이 timestamps가 true면 시퀄라이즈는 createdAt과 updatedAt 컬럼을 추가하며 행이 생성 될때와 수정될 때의 시간을 자동으로 입력한다.

 

하지만 여기서는 created_at 컬럼을 직접만들었으므로 timestamps는 false로 하였다.

참고로 paranoid: true 도 많이 사용하는데 이러면 deletedAt이라는 컬럼이 추가되어 행이 삭제 되었을 때 제거하는 대신 deletedAt에 제거된 날짜를 입력한다.

 

실무에서는 데이터베이스 복원을 위하여 데이터 삭제는 왠만해선 하지 않는다. 사이트에서 회원탈퇴해도 같은 아이디로는 재가입할 수 없는 것도 이러한 이치.

 

이 외에도 underscored 옵션을 사용하여 캐멀형식이 아닌 _를 중간에 써주어 created_at 처럼 표기시킬 수도 있다.

 

comment 모델도 만들어 보자.

models/comment.js

module.exports = (sequelize, DataTypes) => {
    return sequelize.define('comment', {
        comment: {
            type: DataTypes.STRING(100),
            allowNull: false,
        },
        created_at: {
            type: DataTypes.DATE,
            allowNull: true,
            defaultValue: DataTypes.NOW,
        },
    }, {
        timestamps: false,
    });
};

 

아까 위에서 index.js에서 보듯이 db라는 객체에 user와 comment 모델을 담아두었다.

models/index.js

const path = require('path');
const Sequelize = require('sequelize'); //sequelize 연결

const env = process.env.NODE_ENV || 'development';
const config = require(path.join(__dirname, '..', 'config', 'config.json'))[env];
const db = {};

const sequelize = new Sequelize(config.database, config.username, config.password, config);


db.sequelize = sequelize;
db.Sequelize = Sequelize;

//user와 comment 테이블을 연결시킨다.
db.User = require('./user')(sequelize, Sequelize);
db.Comment = require('./comment')(sequelize, Sequelize); 

//테이블 간의 관계를 정의해줌
db.User.hasMany(db.Comment, {foreignKey: 'commenter', sourceKey: 'id'});
db.Comment.belongsTo(db.User, {foreignKey: 'commenter', targetKey: 'id'});

module.exports = db; //db라는 객체에 user와 comment 모델을 담는다.

db객체를 require하여 User와 Comment 모델에 접근할 수 있다.

 

마지막으로 config.json을 수정하여 mysql 비밀번호를 입력하여 연결시켜준다.

본인은 비밀번호는 12351235로 하였다. 

config/config.json

{
  "development": {
    "username": "root",
    "password": "12351235",
    "database": "nodejs",
    "host": "127.0.0.1",
    "dialect": "mysql",
    "operatorsAliases": false
  },
  "test": {
    "username": "root",
    "password": null,
    "database": "database_test",
    "host": "127.0.0.1",
    "dialect": "mysql",
    "operatorsAliases": false
  },
  "production": {
    "username": "root",
    "password": null,
    "database": "database_production",
    "host": "127.0.0.1",
    "dialect": "mysql",
    "operatorsAliases": false
  }
}

 

그리고 나머지 html 코딩파일은 아래의 파일을 다운로드 받아서 덮어쓰기 한다.

 

 

learn-sequelize.zip
6.28MB

 

 

그 뒤 npm start를 실행시킨다.

 

localhost:3000으로 들어가면 아래와 같은 페이지가 나타난다.

위에 이름나이를 등록하고 중간에 리스트를 클릭하면 아래에 클릭한 리스트가 나타난다.

 

 

 

 

 

 

 

 

 

 

 

1. Insert 문

SQL문법

INSERT INTO nodejs.users (name, age, married, comment) VALUES ('zero', 24, 0, '자기소개1');

sequelize 문법

const { User } = require('../models')
User.create({
name: 'zero',
age: 24,
married: false,
comment: '자기소개1',
});

 

이하 아래부터는 위는 SQL문 아래는 seq문법이다.

 

 

 

- SELECT * FROM nodejs.users;

- User.findALL({});

 

- SELECT * FROM nodejs.users LIMIT 1;

- User.findOne({});

 

- SELECT name, married FROM nodejs.users;

- User.findALL({

  attributes: ['name', 'married'],

});

 

- SELECT name, age FROM nodejs.users WHERE married =1 AND age > 30;

 

- const { User, Sequelize : {Op}} = require('../models');

User.findAll({

  attributes: ['name', 'age'],

where: {

  married: 1,

age: { [Op.gt]: 30 },

},

});

 

- SELECT id, name FROM users ORDER BY age DESC;

- User.findAll({

  attributes: ['id', 'name'],

order: [[ 'age', 'DESC']],

});

 

- UPDATE nodejs.users SET comment = '바꿀 내용' WHERE id = 2;

- User.update({

  comment: '바꿀 내용',

}, {

  where : { id : 2 },

});

 

- DELETE FROM nodejs.users WHERE id = 2;

- User.destroy({

 where: { id : 2},

});

 

1. mysql installer를 이용하여 mysql connector 설치

 이 때 아이디는 root이며 비밀번호는 우선 12351235로 설정

 

또한 workbench도 같이 설치

 

mysql installer download 링크

https://dev.mysql.com/downloads/file/?id=490394

 

MySQL :: Begin Your Download

The world's most popular open source database

dev.mysql.com

리눅스의 경우 아래를 따른다.

$ sudo apt-get update
$ sudo apt-get install -y mysql-server-5.7
$ mysql_secure_installation

 

 

2. db연결 및 테이블 생성

C:\Program Files\MySQL\MySQL Server 8.0\bin 로 들어가서 mysql 실행

mysql -h localhost -u root -p
Enter password: 12351235
mysql>

 

nodejs 스키마를 생성하고 이 스키마를 사용하겠다는 것을 MySQL에 알림

 

mysql> CREATE SCHEMA nodejs;
Query OK, 1 row affected (0.01 sec)

mysql> use nodejs;
Database changed

 

nodejs 데이터베이스의 users 테이블 생성

아래 코드를 입력한다.

CREATE TABLE nodejs.users(
id INT NOT NULL AUTO_INCREMENT,
name VARCHAR(20) NOT NULL,
age INT UNSIGNED NOT NULL,
married TINYINT NOT NULL,
comment TEXT NULL,
created_at DATETIME NOT NULL DEFAULT now(),
PRIMARY KEY(id),
UNIQUE INDEX name_UNIQUE (name ASC))
COMMENT = '사용자 정보'
DEFAULT CHARSET=utf8
ENGINE=InnoDB;

 

결과

mysql> CREATE TABLE nodejs.users(
    -> id INT NOT NULL AUTO_INCREMENT,
    -> name VARCHAR(20) NOT NULL,
    -> age INT UNSIGNED NOT NULL,
    -> married TINYINT NOT NULL,
    -> comment TEXT NULL,
    -> created_at DATETIME NOT NULL DEFAULT now(),
    -> PRIMARY KEY(id),
    -> UNIQUE INDEX name_UNIQUE (name ASC))
    -> COMMENT = '사용자 정보'
    -> DEFAULT CHARSET=utf8
    -> ENGINE=InnoDB;
Query OK, 0 rows affected, 1 warning (0.07 sec)

 

table 정보 확인

mysql> DESC users;
+------------+------------------+------+-----+-------------------+-------------------+
| Field      | Type             | Null | Key | Default           | Extra             |
+------------+------------------+------+-----+-------------------+-------------------+
| id         | int(11)          | NO   | PRI | NULL              | auto_increment    |
| name       | varchar(20)      | NO   | UNI | NULL              |                   |
| age        | int(10) unsigned | NO   |     | NULL              |                   |
| married    | tinyint(4)       | NO   |     | NULL              |                   |
| comment    | text             | YES  |     | NULL              |                   |
| created_at | datetime         | NO   |     | CURRENT_TIMESTAMP | DEFAULT_GENERATED |
+------------+------------------+------+-----+-------------------+-------------------+
6 rows in set (0.01 sec)

 

그 뒤, 사용자의 댓글을 저장하는 테이블 생성

아래 코드 입력

CREATE TABLE nodejs.comments (
id INT NOT NULL AUTO_INCREMENT,
commenter INT NOT NULL,
comment VARCHAR(100) NOT NULL,
created_at DATETIME NOT NULL DEFAULT now(),
PRIMARY KEY(id),
INDEX commenter_idx (commenter ASC),
CONSTRAINT commenter
FOREIGN KEY (commenter)
REFERENCES nodejs.users (id)
ON DELETE CASCADE
ON UPDATE CASCADE)
COMMENT = '댓글'
DEFAULT CHARSET=utf8
ENGINE=InnoDB;

 

결과

mysql> CREATE TABLE nodejs.comments (
    -> id INT NOT NULL AUTO_INCREMENT,
    -> commenter INT NOT NULL,
    -> comment VARCHAR(100) NOT NULL,
    -> created_at DATETIME NOT NULL DEFAULT now(),
    -> PRIMARY KEY(id),
    -> INDEX commenter_idx (commenter ASC),
    -> CONSTRAINT commenter
    -> FOREIGN KEY (commenter)
    -> REFERENCES nodejs.users (id)
    -> ON DELETE CASCADE
    -> ON UPDATE CASCADE)
    -> COMMENT = '댓글'
    -> DEFAULT CHARSET=utf8
    -> ENGINE=InnoDB;
Query OK, 0 rows affected, 1 warning (0.06 sec)

테이블명 확인

mysql> SHOW TABLES;
+------------------+
| Tables_in_nodejs |
+------------------+
| comments         |
| users            |
+------------------+
2 rows in set (0.00 sec)

 

워크벤치 GUI를 이용하여 테이블을 만드는 것이 일반적임.

 

3. CRUD 작업하기

CREATE (행 생성)

mysql> INSERT INTO nodejs.users (name, age, married, comment) VALUES ('zero', 24, 0, '자기소개1');
Query OK, 1 row affected (0.02 sec)

mysql> INSERT INTO nodejs.users (name, age, married, comment) VALUES ('nero', 32, 1, '자기소개2');
Query OK, 1 row affected (0.01 sec)
mysql> INSERT INTO nodejs.comments (commenter, comment) VALUES (1, '안녕하세요. zero의 댓글입니다.');
Query OK, 1 row affected (0.01 sec)

 

READ (조회)

mysql> SELECT * FROM nodejs.users;
+----+------+-----+---------+-----------+---------------------+
| id | name | age | married | comment   | created_at          |
+----+------+-----+---------+-----------+---------------------+
|  1 | zero |  24 |       0 | 자기소개1 | 2019-11-03 23:00:10 |
|  2 | nero |  32 |       1 | 자기소개2 | 2019-11-03 23:00:44 |
+----+------+-----+---------+-----------+---------------------+
2 rows in set (0.00 sec)
mysql> SELECT * FROM nodejs.comments;
+----+-----------+--------------------------------+---------------------+
| id | commenter | comment                        | created_at          |
+----+-----------+--------------------------------+---------------------+
|  1 |         1 | 안녕하세요. zero의 댓글입니다. | 2019-11-03 23:03:32 |
+----+-----------+--------------------------------+---------------------+
1 row in set (0.00 sec)

 

UPDATE (수정)

mysql> UPDATE nodejs.users SET comment = '바꿀 내용' WHERE id = 2;
Query OK, 1 row affected (0.01 sec)
Rows matched: 1  Changed: 1  Warnings: 0

 

DELETE (삭제)

mysql> DELETE FROM nodejs.users WHERE id = 2;

 

스프링 프레임워크에서 myBatis사용하여 mySQL db연동하는 방법

 

결론적으로 아래와 같이 파일구성이 되야한다.

 

 

예제파일-----

 

jdbcTest2.zip
0.03MB

--------

 

그럼 차근차근 진행해본다.

 

 

1. src/main/resources에 파일 생성

 

1) mybatis-config.xml 파일 생성

 

아래 코드를 mybatis-config.xml에 넣는다.

 

이 파일을 생성하여야 log dependency를 넣었을 때 오류가 나지 않는다.

 

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>

</configuration>

 

2) log4jdbc.log4j2.properties 파일 생성

 

아래코드를 log4jdbc.log4j2.properties에 넣는다.

log4jdbc에 접속시켜주는 역할을 한다.

 

log4jdbc.log4j2.properties

log4jdbc.spylogdelegator.name=net.sf.log4jdbc.log.slf4j.Slf4jSpyLogDelegator

 

3) logback.xml 생성

 

레벨을 설정해주는 파일이다.

 

아래코드를 logback.xml에 넣는다.

 

logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <include resource="org/springframework/boot/logging/logback/base.xml"/>

    log4jdbc-log4j2
	<logger name="jdbc.sqlonly"        level="DEBUG"/>
    <logger name="jdbc.sqltiming"      level="INFO"/>
    <logger name="jdbc.audit"          level="WARN"/>
    <logger name="jdbc.resultset"      level="ERROR"/>
    <logger name="jdbc.resultsettable" level="ERROR"/>
    <logger name="jdbc.connection"     level="INFO"/>
</configuration>

 

아래와 같이 파일들이 생성된다.

2. dependency 주입

 

pom.xml에 스프링, jdbc, 로그 관련 의존성을 주입한다.

 

아래 코드를 pom.xml에 붙여넣기한다.

<!-- db 연결 관련 -->
		<!-- spring-jdbc -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>
			<!-- mysql-connector-java -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.38</version>
		</dependency>
			<!-- MyBatis 관련 -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.3.1</version>
		</dependency>
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis-spring</artifactId>
			<version>1.2.5</version>
		</dependency>
				<!-- log 관련 -->
		<dependency>
			<groupId>org.bgee.log4jdbc-log4j2</groupId>
			<artifactId>log4jdbc-log4j2-jdbc4.1</artifactId>
			<version>1.16</version>
		</dependency>	
        
        				<!-- sprint-test 관련-->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>4.2.5.RELEASE</version>
		</dependency>

 

그리고 <properties>태그안에 org.springframework-version을 4.2.3으로 변경시킨다.

	<properties>
		<java-version>1.6</java-version>
		<org.springframework-version>4.2.3.RELEASE</org.springframework-version>
		<org.aspectj-version>1.6.10</org.aspectj-version>
		<org.slf4j-version>1.6.6</org.slf4j-version>
	</properties>

 

 

3. VO와 DAO 생성

 

1) VO 생성

com.mysql.domain에 memberVO.java를 생성하여 아래 코드들을 넣는다.

 

MemberVO.java

package com.mysql.domain;

import java.sql.Date;

public class memberVO {

	String userid;
	String userpw;
	String username;
	String email;
	Date regdate;
	Date updatedate;
	
	public String getUserid() {
		return userid;
	}
	public void setUserid(String userid) {
		this.userid = userid;
	}
	public String getUserpw() {
		return userpw;
	}
	public void setUserpw(String userpw) {
		this.userpw = userpw;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public Date getRegdate() {
		return regdate;
	}
	public void setRegdate(Date regdate) {
		this.regdate = regdate;
	}
	public Date getUpdatedate() {
		return updatedate;
	}
	public void setUpdatedate(Date updatedate) {
		this.updatedate = updatedate;
	}
	@Override
	public String toString() {
		return "MemberVO [userid=" + userid + ", userpw=" + userpw + ", username=" + username + ", email=" + email
				+ ", regdate=" + regdate + ", updatedate=" + updatedate + "]";
	}
}

 

2) DAO 생성

 

DAO는 데이터베이스와 연결시켜주는 역할을 한다.

 

1) com.mysql.persistence에 memberDAO.java를 생성하여 아래 코드들을 넣는다.

 

MemberDAO.java

package com.mysql.persistence;

import com.mysql.domain.MemberVO;

// 타입만 명세
	public interface MemberDAO extends GenericDAO<MemberVO, String> {

	}// interface


 

2) com.mysql.persistence에 memberDAOImpl.java를 생성하여 아래 코드들을 넣는다.

 

MemberDAOImpl.java

package com.mysql.persistence;

import org.springframework.stereotype.Repository;
import com.mysql.domain.MemberVO;


@Repository
public class MemberDAOImpl extends GenericDAOImpl<MemberVO, String> implements MemberDAO {

}

 

3) com.mysql.persistence에 GenericDAO.java를 생성하여 아래 코드들을 넣는다.

 

GenericDAO.java

package com.mysql.persistence;

import java.util.List;

public interface GenericDAO<E, K> {

	public K getTime();
	public void register(E vo);
	public E get(K userid);
	public List<E> getList();
	// 아래는 등록, 조회 구현 이후에 할 것임..
	//public void update();
	//public void delete();
	
}// interface

 

4) com.mysql.persistence에 GenericDAOImpl.java를 생성하여 아래 코드들을 넣는다.

 

GenericDAOImpl.java

package com.mysql.persistence;


import java.util.List;
import javax.inject.Inject;
import org.apache.ibatis.session.SqlSession;

// GenericDAO 인터페이스의 추상클래스들을 오버라이딩 해주어야 한다.
// 즉, 여기서 DB와 연결을 하고 SQL문을 처리해주어야 하므로 sessionTemplate을 인스턴스 변수로 갖고서 
// 이를 통해 CRUD 작업을 처리해주면 된다.
public abstract class GenericDAOImpl<E, K> implements GenericDAO<E, K> {

	@Inject
	private SqlSession sqlSession;
	
	private static final String namespace = 
			"com.mysql.mapper.MemberMapper";
	
	@Override
	public K getTime() {
		return sqlSession.selectOne(namespace + ".getNow");
	}

	@Override
	public void register(E vo) {
		sqlSession.insert(namespace + ".register", vo);
	}

	@Override
	public E get(K userid) {
		return sqlSession.selectOne(namespace + ".get", userid);
	}

	@Override
	public List<E> getList() {
		return sqlSession.selectList(namespace + ".getList");
	}

}// class

 

5) com.mysql.persistence에 TimeDao.java를 생성하여 아래 코드들을 넣는다.

 

TimeDAO.java

package com.mysql.persistence;


import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

import javax.inject.Inject;
import javax.sql.DataSource;

import org.springframework.stereotype.Repository;


@Repository
public class TimeDAO {

	@Inject
	private DataSource ds;
	
	
	public String getTime() throws Exception{
		
		Connection conn = ds.getConnection();
		PreparedStatement pstmt = conn.prepareStatement("select now()");
		
		ResultSet rs = pstmt.executeQuery();
		
		rs.next();
		return rs.getString(1);
		
	}// getTime()
	
	
}

 

4. root-context 코드 추가

 

root-context.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.2.xsd">
	
	<!-- Root Context: defines shared resources visible to all other web components -->
		
		
	<!-- JDBC의 연결을 처리하는 기능을 가진 DataSource -->
	<bean id="dataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="net.sf.log4jdbc.sql.jdbcapi.DriverSpy"></property>
		<property name="url" value="jdbc:log4jdbc:mysql://127.0.0.1:3306/book_ex"></property>
		<property name="username" value="zerock"></property>
		<property name="password" value="12351235"></property>
	</bean>

	<!-- SqlSessionFactoryBean 생성 -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
 		<!-- mybatis-config.xml 파일이 스프링이 동작할 때 같이 동작하도록 설정한 것. -->
		<property name="configLocation" value="classpath:mybatis-config.xml"></property>
		<property name="dataSource" ref="dataSource"></property>
		<property name="mapperLocations" value="classpath:mappers/**/*.xml"></property>
	</bean>

	<!-- sqlSession 을 SqlSessionTemplate으로 만든다. -->
	<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
		<constructor-arg index="0" ref="sqlSessionFactory" />
	</bean>


	<!-- 스프링이 관리하는 패키지에 com.mysql.persistence 를 추가한다. -->
	<context:component-scan base-package="com.mysql.persistence" />
	
</beans>

 

5. mapper 추가

 

resources에 mappers라는 패키지를 추가한 뒤에 memberMapper.xml 파일을 만든다.

 

그 뒤 아래 코드를 붙여넣는다.

 

memberMapper.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.mysql.mapper.MemberMapper">

	<!-- 이거에 접근할 때 namespace.id 로 접근한다. -->
	<!-- resultType은 자바의 타입과 매핑되는 것이 있다. 여기선 string이 java.lang.String과 매핑 -->
	<select id="getNow" resultType="string">
		select now()   <!-- 세미콜론 쓰면 안됨 -->
	</select>
	
	<insert id="register">
		insert into tbl_member(userid, userpw, username, email)
		values( #{userid} , #{userpw}, #{username}, #{email} );
	</insert>
	
	<!-- 
			XML Mapper를 작성할 때 매번 resultType을 패키지까지 포함된 클래스명을 작성하는 일이 번거롭다면
			MyBatis의 설정 파일인 mybatis-config.xml을 사용해서 다음과 같이 <typeAliases>를 작성하면된다.
			<typeAliases>
				<package name = "org.zerock.domain"/>
			</typeAliases>		
	-->
	<select id="get" resultType="com.mysql.domain.MemberVO">
		select *
		from tbl_member
		where userid = #{userid}
	
	</select>
	
	<select id="getList" resultType="com.mysql.domain.MemberVO">
		select *
		from tbl_member;
	</select>
</mapper>

 

 

6. src/test/java 폴더의 controller 패키지에 자바파일들 추가

 

AbstractTest.java

package com.mysql.controller;

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/* 모든 테스트 파일이 상속할 추상클래스
 * - 어노테이션 자동 추가
 * - Logger 
 * */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"file:src/main/webapp/WEB-INF/spring/**/*.xml"})
public abstract class AbstractTest {

	protected static final Logger logger = 
			LoggerFactory.getLogger(AbstractTest.class);

}

 

ApplicationContextTest.java

package com.mysql.controller;
/*
 * 2016.04.02 테스트 완료
 * by wjheo
 */

import javax.inject.Inject;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

public class ApplictationContextTest extends AbstractTest{

	@Inject
	private ApplicationContext ctxt;
	
	
	@Test
	public void test() {
		logger.info(""+ctxt);
		
	}// test()

}// class

 

DataSourceConnectionTest.java

/*
 * 2016.04.02 테스트 완료
 * by wjheo
 */
package com.mysql.controller;

import static org.junit.Assert.fail;

import java.sql.SQLException;

import javax.inject.Inject;
import javax.sql.DataSource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

public class DataSourceConnectionTest extends AbstractTest{
	
	@Inject
	private DataSource ds;
	
	@Test
	public void test() throws SQLException {
		logger.info(""+ds.getConnection());
	}// test()

}// class

 

MemberDAOImplTest.java

/*
 * 2016.04.02 테스트 완료
 * by wjheo
 */
package com.mysql.controller;

import javax.inject.Inject;

import org.junit.Test;
import com.mysql.domain.MemberVO;
import com.mysql.persistence.MemberDAO;

public class MemberDAOImplTest extends AbstractTest{

	@Inject
	private MemberDAO dao;
	
	@Test
	public void test() {
		logger.info(""+dao);
	}
	
	@Test
	public void getTimeTest() {
		logger.info(""+dao.getTime());
	}
	
	@Test
	public void registerTest(){
		MemberVO vo = new MemberVO();
		vo.setUserid("fff");
		vo.setUserpw("cccc");
		vo.setUsername("ejg");
		vo.setEmail("ej@g.com");
		
		// DB에 넣고 DB테이블에서 직접 확인해봐야 한다.
		dao.register(vo);
	}
	
//	@Test
//	public void getTest(){
//		logger.info(""+dao.get("wjheoid"));
//	}
//	
//	@Test
//	public void getListTest(){
//		logger.info(""+dao.getList());
//	}
	
}// class

 

SqlSessionFactoryBeanTest.java

/*
 * 2016.04.02 테스트 완료
 * by wjheo
 */
package com.mysql.controller;

import javax.inject.Inject;

import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

public class SqlSessionFactoryBeanTest extends AbstractTest{

	@Inject
	SqlSessionFactoryBean factoryBean;
	
	@Test
	public void test(){
		logger.info(""+factoryBean);
	}// test()
	
	@Test
	public void sesseionTest(){
		try {
			logger.info(""+factoryBean.getObject().openSession().toString());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}// test()
	
}// class

 

TimeDAOTest.java

package com.mysql.controller;
/*
 * 2016.04.02 테스트 완료
 * by wjheo
 */

import static org.junit.Assert.fail;

import javax.inject.Inject;

import org.junit.Test;
import com.mysql.persistence.TimeDAO;

public class TimeDAOTest extends AbstractTest{

	@Inject
	private TimeDAO dao;
	
	@Test
	public void test() throws Exception {
		logger.info(""+dao.getTime());
		
	}// test()
}// class

 

아래와 같이 파일들이 구성되어야 함

 

이후 MemberDAOImplTest에서 테스트를 하면 db에 값이 저장됨

 

위에 값들은 vo를 참조하여 만들면 된다.

+ Recent posts