1. Spring 3.0+JDBC(Web 환경) 


1) SpirngWeb 프로젝트 생성


Web에서 DB를 연결하는 방법은 (JDBC - Spring JDBC - Mybatis) 이렇게 3가지가 있다.


-Spring3.0을 웹으로 JDBC와 연결해보겠다.


-기본세팅파일

SpringWeb_기본세팅.zip


-폴더 구조


2) BoardController.java 작성 - created, list(글 작성, 글목록 기능)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
package com.jdbc.springweb;
 
 
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.List;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
 
import com.jdbc.dao.BoardDAO;
import com.jdbc.dto.BoardDTO;
import com.jdbc.util.MyUtil;
 
@Controller
public class BoardController {
    
    @Autowired
    @Qualifier("boardDAO")
    BoardDAO dao;
    
    @Autowired
    MyUtil myUtil;
    
    @RequestMapping(value = "/created.action")
    public ModelAndView created() {
        ModelAndView mav=new ModelAndView();
        mav.setViewName("bbs/created");
        
        return mav;
    }
    
    @RequestMapping(value="/created_ok.action",method = {RequestMethod.GET,RequestMethod.POST})
    public String created_ok(BoardDTO dto, HttpServletRequest request, HttpServletResponse response) throws Exception{
        
        int maxNum=dao.getMaxNum();
        
        dto.setNum(maxNum+1);
        dto.setIpAddr(request.getRemoteAddr());
        
        dao.insertData(dto);
        
        return "redirect:/list.action";
    }
    
    @RequestMapping(value="/list.action",method = {RequestMethod.GET,RequestMethod.POST})
    public String list(HttpServletRequest request, HttpServletResponse response) throws Exception{
        
        String cp = request.getContextPath();
        
        String pageNum = request.getParameter("pageNum");
        int currentPage = 1;
        
        if(pageNum != null)
            currentPage = Integer.parseInt(pageNum);
        
        String searchKey = request.getParameter("searchKey");
        String searchValue = request.getParameter("searchValue");
        
        if(searchKey == null){
            
            searchKey = "subject";
            searchValue = "";
            
        }else{
            
            if(request.getMethod().equalsIgnoreCase("GET"))
                searchValue =
                    URLDecoder.decode(searchValue, "UTF-8");
            
        }
        
        //전체데이터갯수
        int dataCount = dao.getDataCount(searchKey, searchValue);
        
        //전체페이지수
        int numPerPage = 10;
        int totalPage = myUtil.getPageCount(numPerPage, dataCount);
        
        if(currentPage > totalPage)
            currentPage = totalPage;
        
        int start = (currentPage-1)*numPerPage+1;
        int end = currentPage*numPerPage;
        
        List<BoardDTO> lists =
            dao.getList(start, end, searchKey, searchValue);
        
        //페이징 처리
        String param = "";
        if(!searchValue.equals("")){
            param = "searchKey=" + searchKey;
            param+= "&searchValue=" 
                + URLEncoder.encode(searchValue, "UTF-8");
        }
        
        String listUrl = cp + "/list.action";
        if(!param.equals("")){
            listUrl = listUrl + "?" + param;                
        }
        
        String pageIndexList =
            myUtil.pageIndexList(currentPage, totalPage, listUrl);
        
        //글보기 주소 정리
        String articleUrl = 
            cp + "/article.action?pageNum=" + currentPage;
            
        if(!param.equals(""))
            articleUrl = articleUrl + "&" + param;
        
        //포워딩 될 페이지에 데이터를 넘긴다
        request.setAttribute("lists", lists);
        request.setAttribute("pageIndexList",pageIndexList);
        request.setAttribute("dataCount",dataCount);
        request.setAttribute("articleUrl",articleUrl);
        
        return "bbs/list";
    }
}
cs

created, list 기능만 추가한 코드이다.


-실행화면


3) article 추가(게시글 보기 기능)

컨트롤러에 article 추가한다.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
    @RequestMapping(value="/article.action",method = {RequestMethod.GET,RequestMethod.POST})
    public String article(HttpServletRequest request, HttpServletResponse response) throws Exception{
        
        String cp = request.getContextPath();
        
        int num = Integer.parseInt(request.getParameter("num"));
        String pageNum = request.getParameter("pageNum");
        
        String searchKey = request.getParameter("searchKey");
        String searchValue = request.getParameter("searchValue");
        
        if(searchKey != null)
            searchValue = URLDecoder.decode(searchValue, "UTF-8");
        
        //조회수 증가
        dao.updateHitCount(num);
        
        BoardDTO dto = dao.getReadData(num);
        
        if(dto==null){
            return "redirect:/list.action";
        }
        
        int lineSu = dto.getContent().split("\n").length;
        
        dto.setContent(dto.getContent().replaceAll("\n", "<br/>"));
        
        String param = "pageNum=" + pageNum;
        if(searchKey!=null){
            param += "&searchKey=" + searchKey;
            param += "&searchValue=" 
                + URLEncoder.encode(searchValue, "UTF-8");
        }
        
        request.setAttribute("dto", dto);
        request.setAttribute("params",param);
        request.setAttribute("lineSu",lineSu);
        request.setAttribute("pageNum",pageNum);        
        
        return "bbs/article";    
    }
cs


**여기서 return값을 ModelAndView로 바꿔줄경우!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
    @RequestMapping(value="/article.action",method = {RequestMethod.GET,RequestMethod.POST})
    public ModelAndView article(HttpServletRequest request, HttpServletResponse response) throws Exception{
        
        String cp = request.getContextPath();
        
        int num = Integer.parseInt(request.getParameter("num"));
        String pageNum = request.getParameter("pageNum");
        
        String searchKey = request.getParameter("searchKey");
        String searchValue = request.getParameter("searchValue");
        
        if(searchKey != null)
            searchValue = URLDecoder.decode(searchValue, "UTF-8");
        
        //조회수 증가
        dao.updateHitCount(num);
        
        BoardDTO dto = dao.getReadData(num);
        
        if(dto==null){
            //return "redirect:/list.action";
        }
        
        int lineSu = dto.getContent().split("\n").length;
        
        dto.setContent(dto.getContent().replaceAll("\n", "<br/>"));
        
        String param = "pageNum=" + pageNum;
        if(searchKey!=null){
            param += "&searchKey=" + searchKey;
            param += "&searchValue=" 
                + URLEncoder.encode(searchValue, "UTF-8");
        }
        /*
        //model
        request.setAttribute("dto", dto);
        request.setAttribute("params",param);
        request.setAttribute("lineSu",lineSu);
        request.setAttribute("pageNum",pageNum);        
        
        //view
        //return "bbs/article";    
        */
        
        ModelAndView mav=new ModelAndView();
        mav.setViewName("bbs/article");
        mav.addObject("dto",dto);
        mav.addObject("params",param);
        mav.addObject("lineSu",lineSu);
        mav.addObject("pageNum",pageNum);
        
        return mav;
    }
cs

반환값의 자료형을 ModelAndView로 바꾸고 아래쪽에 request.setAttribute~ 주석친 부분을 그  아래 코드처럼 써주면 된다.


4) update 추가(수정 기능)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
    @RequestMapping(value="/updated.action",method = {RequestMethod.GET,RequestMethod.POST})
    public String updated(HttpServletRequest request, HttpServletResponse response) throws Exception{
 
        String cp=request.getContextPath();
        
        int num = Integer.parseInt(request.getParameter("num"));
        String pageNum = request.getParameter("pageNum");
        
        BoardDTO dto = dao.getReadData(num);
        
        if(dto == null){
            return "redirect:/list.action";
        }
        
        request.setAttribute("dto", dto);
        request.setAttribute("pageNum", pageNum);
        
        return "bbs/updated";    
    }
    
    @RequestMapping(value="/updated_ok.action",method = {RequestMethod.GET,RequestMethod.POST})
    public String updated_ok(BoardDTO dto,HttpServletRequest request, HttpServletResponse response) throws Exception{
    
        String pageNum = request.getParameter("pageNum");
        
        dao.updateData(dto);
        
        return "redirect:/list.action?pageNum="+pageNum;
    }
cs


5)delete 추가


1
2
3
4
5
6
7
8
9
10
    @RequestMapping(value="/deleted.action",method = {RequestMethod.GET,RequestMethod.POST})
    public String deleted(BoardDTO dto,HttpServletRequest request, HttpServletResponse response) throws Exception{
    
        String pageNum = request.getParameter("pageNum");
        int num =Integer.parseInt(request.getParameter("num"));
        
        dao.deleteData(num);
        
        return "redirect:/list.action?pageNum="+pageNum;
    }
cs


6) 전체 실행화면



2. Spring 3.0+Spring JDBC(Web 환경) 


1) Spring JDBC lib 다운

링크 : https://mvnrepository.com/

Spring JDBC 다운받아서 pom.xml에 붙여넣는다.


-pom.xml

1
2
3
4
5
6
        <!-- spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${org.springframework-version}</version>
        </dependency>
cs


2) DAO 파일 생성 및 작성

먼저 xml파일에 객체 생성해주고 메소드를 통한 의존성 주입을 위한 세팅을 먼저 해주자.


-servlet-context.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
    <beans:bean id="boardDAO2" class="com.jdbc.dao.BoardDAO2">
        <beans:property name="jdbcTemplate" ref="jdbcTemplate"/>
    </beans:bean>
    
    <beans:bean id="jdbcTemplate"
    class="org.springframework.jdbc.core.JdbcTemplate">
        <beans:constructor-arg ref="dataSource"/>
    </beans:bean>
    
    <beans:bean id="dataSource"
    class="org.apache.commons.dbcp.BasicDataSource"
    destroy-method="close">
        <beans:property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
        <beans:property name="url" value="jdbc:oracle:thin:@192.168.16.12:1521:TestDB"/>
        <beans:property name="username" value="suzi"/>
        <beans:property name="password" value="a123"/>
    </beans:bean>
cs

boardDAO2를 만들고 의존성 주입을 위한 셋팅.


-BoardDAO2.java

1
2
3
4
5
6
    //DI(의존성 주입)
    private JdbcTemplate jdbcTemplate;
    
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) throws Exception{
        this.jdbcTemplate = jdbcTemplate;
    }
cs

메소드로 의존성주입을 하였다.


-아래는 BoardDAO2의 DB를 다루는 코드 전문.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
package com.jdbc.dao;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
 
import javax.sql.DataSource;
 
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
 
import com.jdbc.dto.BoardDTO;
 
public class BoardDAO2 {
    
    private JdbcTemplate jdbcTemplate;
    
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) throws Exception{
        this.jdbcTemplate = jdbcTemplate;
    }
    
    public int getMaxNum(){
        
        int maxNum = 0;
        
        StringBuilder sql=new StringBuilder(100);//100자 저장하겠다.
        
        sql.append("select nvl(max(num),0) from board");
        maxNum=jdbcTemplate.queryForInt(sql.toString());
 
        return maxNum;
    }
    
    public void insertData(BoardDTO dto){
        
        StringBuilder sql=new StringBuilder(200);
            
        sql.append("insert into board (num,name,pwd,email,subject,content,");
        sql.append("ipAddr,hitCount,created) ") ;
        sql.append( "values(?,?,?,?,?,?,?,0,sysdate)");
        
        jdbcTemplate.update(sql.toString(),dto.getNum(),dto.getName(),dto.getPwd()
                ,dto.getEmail(),dto.getSubject(),dto.getContent(),dto.getIpAddr());
    
    }
    
    public List<BoardDTO> getList(int start, int end,
            String searchKey, String searchValue){
 
        StringBuilder sql=new StringBuilder(500);
            
        searchValue = "%" + searchValue + "%";
        
        sql.append("select * from (")
        .append("select rownum rnum,data.* from(")
        .append("select num,name,subject,hitCount,")
        .append("to_char(created,'YYYY-MM-DD') created ")
        .append("from board where " + searchKey + " like ? order by num desc) data) ")
        .append("where rnum >= ? and rnum <= ?");
        
        List<BoardDTO> lists=jdbcTemplate.query(sql.toString(), 
                new Object[] {searchValue,start,end},
                new RowMapper<BoardDTO>() {
 
                    @Override
                    public BoardDTO mapRow(ResultSet rs, int rowNum) throws SQLException {
                        
                        BoardDTO dto=new BoardDTO();
                        
                        dto.setNum(rs.getInt("num"));
                        dto.setName(rs.getString("name"));
                        dto.setSubject(rs.getString("subject"));
                        dto.setHitCount(rs.getInt("hitCount"));
                        dto.setCreated(rs.getString("created"));
                        
                        return dto;
                    }
            
        });
        
        return lists;
        
    }
    
    public int getDataCount(String searchKey,String searchValue){
        
        int result = 0;
        
        StringBuilder sql=new StringBuilder(200);
            
        searchValue = "%" + searchValue + "%";
        
        sql.append("select nvl(count(*),0) from board ")
        .append("where " + searchKey + " like ?");
            
        result=jdbcTemplate.queryForInt(sql.toString(),searchValue);
 
        return result;
    }
    
 
    public void updateHitCount(int num){
 
        StringBuilder sql=new StringBuilder(500);
        sql.append("update board set hitCount=hitCount + 1 where num=?");
            
        jdbcTemplate.update(sql.toString(),num);
    }
    
    public BoardDTO getReadData(int num){
        
        StringBuilder sql=new StringBuilder(100);
            
        sql.append("select num,name,pwd,email,subject,content,ipAddr,")
        .append("hitCount,created from board where num=?");
 
        BoardDTO dtoOne=jdbcTemplate.queryForObject(sql.toString(),
                new RowMapper<BoardDTO>(){
 
                    @Override
                    public BoardDTO mapRow(ResultSet rs, int rowNum) throws SQLException {
                        
                        BoardDTO dto = new BoardDTO();
                        
                        dto.setNum(rs.getInt("num"));
                        dto.setName(rs.getString("name"));
                        dto.setPwd(rs.getString("pwd"));
                        dto.setEmail(rs.getString("email"));
                        dto.setSubject(rs.getString("subject"));
                        dto.setContent(rs.getString("content"));
                        dto.setIpAddr(rs.getString("ipAddr"));
                        dto.setHitCount(rs.getInt("hitCount"));
                        dto.setCreated(rs.getString("created"));
                        
                        return dto;
                    }
            
            },num);
 
        return dtoOne;
    }
    
    public void deleteData(int num){
        
        StringBuilder sql=new StringBuilder(100);
        
        sql.append("delete board where num=?");
        
        jdbcTemplate.update(sql.toString(),num);
        
    }
 
    public void updateData(BoardDTO dto){
        
        StringBuilder sql=new StringBuilder(100);
        
        sql.append("update board set name=?, pwd=?, email=?, subject=?,")
        .append("content=? where num=?");
        
        jdbcTemplate.update(sql.toString(),dto.getName(),dto.getPwd(),
                dto.getEmail(),dto.getSubject(),dto.getContent(),
                dto.getNum());        
    }
}
cs


-그리고 아까의 BoardController.java에서 dao 연결부분을 바꿔준다.

1
2
3
4
5
6
@Controller
public class BoardController {
    
    @Autowired
    @Qualifier("boardDAO2")
    BoardDAO2 dao;
cs

BoardDAO에서 BoardDAO2를 연결


-그리고 실행하면 게시판이 잘 작동한다.



3. Spring 3.0+Mybatis(Web 환경) 


1) 프로젝트 복사해서 생성(SpringWebMybatis)

SpringWeb을 복사해서 SpringWebMybatis로 생성


-폴더기본셋팅

SpringWebMybatis.zip


2) mvnrepository에서 mybatis,mybatis spring 다운


링크 : https://mvnrepository.com/

-pom.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
        <!-- mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.2</version>
        </dependency>
        
        <!-- mybatis-spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>
cs


3) servlet-context.xml에서 mybatis설정


-servlet-context.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/mvc"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:beans="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
 
    <!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->
    
    <!-- Enables the Spring MVC @Controller programming model -->
    <annotation-driven />
 
    <!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/resources directory -->
    <resources mapping="/resources/**" location="/resources/" />
 
    <!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->
    <beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <beans:property name="prefix" value="/WEB-INF/views/" />
        <beans:property name="suffix" value=".jsp" />
    </beans:bean>
    
    <context:component-scan base-package="com.jdbc.springweb" />
    
    <beans:bean id="boardDAO2" class="com.jdbc.dao.BoardDAO2">
        <beans:property name="sessionTemplate" ref="sessionTemplate"/>
    </beans:bean>
    
    <beans:bean id="sessionTemplate"
    class="org.mybatis.spring.SqlSessionTemplate">
        <beans:constructor-arg ref="sessionFactory"/>    
    </beans:bean>
    
    <beans:bean id="sessionFactory" 
    class="org.mybatis.spring.SqlSessionFactoryBean">
        <beans:property name="dataSource" ref="dataSource"></beans:property>
    </beans:bean>
    
    <beans:bean id="dataSource"
    class="org.apache.commons.dbcp.BasicDataSource"
    destroy-method="close">
        <beans:property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
        <beans:property name="url" value="jdbc:oracle:thin:@192.168.16.12:1521:TestDB"/>
        <beans:property name="username" value="suzi"/>
        <beans:property name="password" value="a123"/>
    </beans:bean>
    
    <beans:bean id="myUtil" class="com.jdbc.util.MyUtil"/>
    
</beans:beans>
cs


4) mybats-config.xml 파일 생성 및 작성


src/main/java에 mybatis-config.xml 파일 생성

1
2
3
4
<!-- spring하고 연결할때는 얘만 필요 -->
<mappers>
    <mapper resource="com/exe/mybatis/boardMapper.xml"/>
</mappers>
cs



그리고 servlet-context.xml에 sessionFactory 객체 생성부분에 property추가 해준다.

1
2
3
4
5
6
    <beans:bean id="sessionFactory" 
    class="org.mybatis.spring.SqlSessionFactoryBean">
        <beans:property name="dataSource" ref="dataSource"></beans:property>
        <beans:property name="configLocation"
        value="classpath:/mybatis-config.xml"/>
    </beans:bean>
cs

configLocation으로 sql문을 써놓은 xml 파일의 경로를 알려준다.


5) boardMapper.xml 생성 및 작성


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
<?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="boardMapper">
 
<select id="maxNum" resultType="int">
    select nvl(max(num),0) from board
</select>
 
<insert id="insertData" parameterType="com.jdbc.dto.BoardDTO">
    insert into board(num,name,pwd,email,subject,content,ipAddr,hitCount,created) 
    values(#{num},#{name},#{pwd},#{email},#{subject},#{content},#{ipAddr},0,sysdate)
</insert>
 
<select id="getDataCount" parameterType="hashMap" resultType="int">
    select nvl(count(*),0) from board
    where ${searchKey} like '%' || #{searchValue} || '%'
</select>
 
<select id="getLists" parameterType="hashMap" resultType="com.jdbc.dto.BoardDTO">
    select * from(
    select rownum rnum, data.* from(
    select num,name,subject,hitCount,to_char(created,'YYYY-MM-DD') created
    from board where ${searchKey} like '%' || #{searchValue} || '%'
    order by num desc) data)
<![CDATA[
    where rnum>=#{start} and rnum<=#{end}
]]>
</select>
 
<select id="getReadData" parameterType="int" resultType="com.jdbc.dto.BoardDTO">
    select num,name,pwd,email,subject,content,ipAddr,hitCount,created
    from board where num=#{num}
</select>
 
<update id="updateHitCount" parameterType="int">
    update board set hitCount=hitCount+1 where num=#{num}
</update>
 
<update id="updateData" parameterType="com.jdbc.dto.BoardDTO">
    update board set name=#{name},pwd=#{pwd},email=#{email},subject=#{subject},
    content=#{content} where num=#{num}
</update>
 
<delete id="delteData" parameterType="int">
    delete board where num=#{num}
</delete>
 
</mapper>
cs


6) DAO 파일 mybatis에 맞게 바꿔준다. 


-BoardDAO2.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
package com.jdbc.dao;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
 
import javax.sql.DataSource;
 
import org.mybatis.spring.SqlSessionTemplate;
 
import com.jdbc.dto.BoardDTO;
 
public class BoardDAO2 {
    
    private SqlSessionTemplate sessionTemplate;
    
    public void setSessionTemplate(SqlSessionTemplate sessionTemplate) throws Exception{
        this.sessionTemplate = sessionTemplate;
    }
    
    Connection conn=null;
    
    public int getMaxNum(){
        
        int maxNum = 0;
        
        maxNum=sessionTemplate.selectOne("boardMapper.maxNum");
        
        return maxNum;
    }
    
    public void insertData(BoardDTO dto){
        
        sessionTemplate.insert("boardMapper.insertData",dto);
    }
    
    public List<BoardDTO> getList(int start, int end,
            String searchKey, String searchValue){
        
        HashMap<String, Object> params=new HashMap<String, Object>();
        params.put("start", start);
        params.put("end", end);
        params.put("searchKey",searchKey);
        params.put("searchValue",searchValue);
    
        List<BoardDTO> lists=sessionTemplate.selectList("boardMapper.getLists",params);
        
        return lists;
    }
    
    public int getDataCount(String searchKey,String searchValue){
        
        int result=0;
        
        HashMap<String, Object> params=new HashMap<String, Object>();
 
        params.put("searchKey",searchKey);
        params.put("searchValue",searchValue);
 
        result=sessionTemplate.selectOne("boardMapper.getDataCount",params);
        
        return result;
    }
    
    public void updateHitCount(int num){
        
        sessionTemplate.update("boardMapper.updateHitCount",num);
    }
    
    public BoardDTO getReadData(int num){
        
        BoardDTO dto = sessionTemplate.selectOne("boardMapper.getReadData",num);
        
        return dto;
    }
    
    public void deleteData(int num){
        
        sessionTemplate.delete("boardMapper.deleteData",num);
    }
    
    public void updateData(BoardDTO dto){
 
        sessionTemplate.update("boardMapper.updateData",dto);    
    }
}
cs


- BoardController.java파일은 저번거 그대로.

그러면 Mybatis를 이용한 게시판도 잘 작동한다.


-실행화면



저작자표시 비영리 변경금지 (새창열림)

1. DB와 연동하기 위해 환경 Setting 


새로운 프로젝트를 만들기위해 NEW> Spring Legacy Project 클릭

프로젝트 이름은 SpringjdbcTemplate 



자바콘솔에서 볼 경우는 Simple Spring Utility Project를 선택해주고

웹에서 볼 경우는 Spring MVC Project를 선택해주면 된다.


패키지 이름은 com.exe.springjdbctemplate로 해준다.


스프링에서 DB를 사용하는 방법은 대표적으로 두가지가 있다.

1. mybatis

2. Spring dao


-테이블 생성

create table custom

(id number,

name char(10),

age number)


저장소를 제공하면 내가 따로 lib를 추가해줄 필요없이 스프링이 자동으로 가져와준다.

Maven이 그 저장소 역할을 한다.


**maven에 라이브러리 추가

-링크: https://mvnrepository.com/


1. Commons DBCP 검색 > 1.4 클릭

하단에 이부분 복붙해서 pom.xml에 붙여넣는다.(pom.xml이 Maven의 환경설정 파일)


2. pool 검색>Commons Pool 1.6도 똑같이 넣어준다.


-pom.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">    
    <dependencies>
        <!-- 생략 -->
        
        <!-- commons-dbcp -->
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        
        <!-- commons-pool -->
        <dependency>
            <groupId>commons-pool</groupId>
            <artifactId>commons-pool</artifactId>
            <version>1.6</version>
        </dependency>
 
    </dependencies>
</project>
cs

: dbcp와 pool을 추가해주었다.


-설치된 라이브러리 파일 확인

C:\Users\itwill\.m2\repository 여기 경로에 lib파일 확인 할수 있다.


2. 스프링에서 JDBC 사용 


-CutomDTO 클래스 파일 생성

1
2
3
4
5
6
7
8
9
10
package com.exe.springjdbctemplate;
 
public class CustomDTO {
    
    private int id;
    private String name;
    private int age;
    
    //getter,setter 생략...
}
cs


-app-context.xml을 프로젝트 패키지에 복사한뒤 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<?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"
    xmlns:p="http://www.springframework.org/schema/p"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    https://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context 
        https://www.springframework.org/schema/context/spring-context-3.0.xsd
        http://www.springframework.org/schema/p">
 
    <description>Example configuration to get you started.</description>
 
    <context:component-scan base-package="com.exe.springjdbctemplate" />
 
    <bean id="customDAO"
    class="com.exe.springjdbctemplate.CustomDAO">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    
    <bean id="dataSource"
    class="org.apache.commons.dbcp.BasicDataSource"
    destroy-method="close"
    p:driverClassName="oracle.jdbc.driver.OracleDriver"
    p:url="jdbc:oracle:thin:@192.168.16.12:1521:TestDB"
    p:username="suzi"
    p:password="a123"
    />
</beans>
cs

: 사용자 정의 파일인 p를 써주고,

db정보인 dataSource 써주고, 그리고 sql문을 적어줄 DAO객체도 생성해준다.


-파일 구조


-CustomDAO.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
package com.exe.springjdbctemplate;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
 
import javax.sql.DataSource;
 
public class CustomDAO {
 
    private DataSource dataSource;
    
    //의존성 주입
    public void setDataSource(DataSource dataSource) {
        this.dataSource=dataSource;
    }
    
    Connection conn=null;
    
    //insert
    public int insertData(CustomDTO dto) {
        int result=0;
        PreparedStatement pstmt=null;
        String sql;
        
        try {
            conn=dataSource.getConnection();
            
            sql="insert into custom(id,name,age) values (?,?,?)";
            pstmt=conn.prepareStatement(sql);
            pstmt.setInt(1, dto.getId());
            pstmt.setString(2, dto.getName());
            pstmt.setInt(3, dto.getAge());
            
            result=pstmt.executeUpdate();
            
            pstmt.close();
            
        } catch (Exception e) {
            System.out.println(e.toString());
        }
        
        return result;
    }
    
    //select 모든 데이터
    public List<CustomDTO> getList(){
        
        List<CustomDTO> lists=new ArrayList<CustomDTO>();
        PreparedStatement pstmt=null;
        ResultSet rs=null;
        String sql;
        
        try {
            conn=dataSource.getConnection();
            
            sql="select id,name,age from custom";
            
            pstmt=conn.prepareStatement(sql);
            rs=pstmt.executeQuery();
            
            while(rs.next()) {
                CustomDTO dto=new CustomDTO();
                
                dto.setId(rs.getInt("id"));
                dto.setName(rs.getString("name"));
                dto.setAge(rs.getInt("age"));
                
                lists.add(dto);
            }
            
            rs.close();
            pstmt.close();
        } catch (Exception e) {
            System.out.println(e.toString());
        }
        
        return lists;
    }
    
    //update
    public int updateData(CustomDTO dto) {
        int result=0;
        PreparedStatement pstmt=null;
        String sql;
        
        try {
            conn=dataSource.getConnection();
            
            sql="update custom set name=?,age=? where id=?";
            pstmt=conn.prepareStatement(sql);
            
            pstmt.setString(1, dto.getName());
            pstmt.setInt(2, dto.getAge());
            pstmt.setInt(3, dto.getId());
            
            result=pstmt.executeUpdate();
            
            pstmt.close();
            
        } catch (Exception e) {
            System.out.println(e.toString());
        }
        
        return result;
    }
    
    //select 1개의 데이터
    public CustomDTO getReadData(int id){
        
        CustomDTO dto=null;
        PreparedStatement pstmt=null;
        ResultSet rs=null;
        String sql;
        
        try {
            conn=dataSource.getConnection();
            
            sql="select id,name,age from custom where id=?";
            
            pstmt=conn.prepareStatement(sql);
            pstmt.setInt(1, id);
            
            rs=pstmt.executeQuery();
            
            if(rs.next()) {
                dto=new CustomDTO();
                
                dto.setId(rs.getInt("id"));
                dto.setName(rs.getString("name"));
                dto.setAge(rs.getInt("age"));
            }
            
            rs.close();
            pstmt.close();
        } catch (Exception e) {
            System.out.println(e.toString());
        }
        
        return dto;
    }
    
    //delete
    public int deleteDate(int id) {
        int result=0;
        PreparedStatement pstmt=null;
        String sql;
        
        try {
            conn=dataSource.getConnection();
            
            sql="delete from custom where id=?";
            pstmt=conn.prepareStatement(sql);
            pstmt.setInt(1, id);
            
            result=pstmt.executeUpdate();
            pstmt.close();
            
        } catch (Exception e) {
            System.out.println(e.toString());
        }
        
        return result;
    }
}
cs


-CustomMain.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package com.exe.springjdbctemplate;
 
import org.springframework.context.support.GenericXmlApplicationContext;
 
public class CustomMain {
 
    public static void main(String[] args) {
        
        GenericXmlApplicationContext context=new GenericXmlApplicationContext("app-context.xml");
        
        CustomDAO dao=(CustomDAO)context.getBean("customDAO");
 
        CustomDTO dto;
        
        dto=new CustomDTO();
        dto.setId(111);
        dto.setName("배수지");
        dto.setAge(25);
        
        dao.insertData(dto);
        
        System.out.println("insert 완료!");
        
    }
}
cs


-실행화면


(자바 콘솔창)


(cmd 창)

: DB에서도 잘 들어간것을 알 수 있다.



** 위에 코드로 DB 연결이 안될 경우 해결방법


위처럼 코딩을 한 경우에 DB에 연결이 안되는 경우가 있다.

이럴 때는 오라클 lib를 pom.xml에 추가해주어야한다. 추가해주어야 할 것은 아래와 같다.


1. ojdbc6 lib

2. 오라클 lib : 오라클은 직접 lib을 못가져다쓰게 해놔서 코드를 좀 다르게 써주어야한다.


-링크: https://mvnrepository.com/ 


1. ojdbc6 검색>12.1.0.1 버전 선택


-pom.xml의 dependencies 안에 아래 코드 추가해준다.

1
2
3
4
5
6
7
        <!-- ojdbc6 -->
        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>ojdbc6</artifactId>
            <version>12.1.0.1-atlassian-hosted</version>
            <scope>test</scope>
        </dependency>
cs


2. oracle lib 추가

아까의 페이지에서 아래의 Atlassian 3rdParty버튼 눌러서

: 이 url을 붙여서 아래의 코드의 url에 써준다.


-pom.xml의 dependencies 밖에 아래 코드 써준다.

1
2
3
4
5
6
7
    <repositories>
        <repository>
            <id>oracle</id>
            <name>Oracle JDBC Repository</name>
            <url>https://packages.atlassian.com/maven-3rdparty/</url>
        </repository>
    </repositories>
cs


-CustomMain.java에서 update,select 등 해보자.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
package com.exe.springjdbctemplate;
 
import java.util.List;
 
import org.springframework.context.support.GenericXmlApplicationContext;
 
public class CustomMain {
 
    public static void main(String[] args) {
        
        GenericXmlApplicationContext context=new GenericXmlApplicationContext("app-context.xml");
        
        CustomDAO dao=(CustomDAO)context.getBean("customDAO");
        
        CustomDTO dto;
        /*
        dto=new CustomDTO();
        dto.setId(111);
        dto.setName("배수지");
        dto.setAge(25);
        
        dao.insertData(dto);
        
        System.out.println("insert 완료!");
        */
        
        //Oneselect
        dto=dao.getReadData(222);
        
        if(dto!=null) {
            System.out.printf("%d %s %d\n",dto.getId(),dto.getName(),dto.getAge());
        }
        
        System.out.println("OneSelect 완료!");
        
        //update
        dto = new CustomDTO();
        
        dto.setId(111);
        dto.setName("권지용");
        dto.setAge(22);
        
        dao.updateData(dto);
        
        //delete
        dao.deleteDate(222);
 
        //select
        List<CustomDTO> lists=dao.getList();
        
        for(CustomDTO dto1:lists) {
            System.out.printf("%d %s %d\n",dto1.getId(),dto1.getName(),dto1.getAge());
        }
        
        System.out.println("select 완료!");
    }
}
cs


-실행화면




3. 스프링에서 Spring JDBC 사용 


-링크: https://mvnrepository.com/artifact/org.springframework/spring-jdbc/5.1.6.RELEASE

spring-jdbc 검색 후 전과 똑같이 하단의 코드를 pom.xml에 붙여넣는다. 

대신 버전은 ${spring.framework.version}이렇게 써줘야한다. (위의 spring.framework.version을 바꾸면 같이 바뀌게)


-pom.xml

1
2
3
4
5
6
        <!-- spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.framework.version}</version>
        </dependency>
cs


**Spring JDBC 사용하려면...


-app-context.xml에 추가

: Spring JDBC써줄려면 jdbcTemplate만들어 주어야한다.


-CustomDAO2.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
package com.exe.springjdbctemplate;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
 
import javax.sql.DataSource;
 
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
 
public class CustomDAO2 {
 
    private JdbcTemplate jdbcTemplate;
    
    //의존성 주입
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate=jdbcTemplate;
    }
    
    Connection conn=null;
    
    //insert
    public void insertData(CustomDTO dto) {
        
        StringBuilder sql=new StringBuilder();
            
        sql.append("insert into custom(id,name,age) values (?,?,?)");
        jdbcTemplate.update(sql.toString(),
                dto.getId(),dto.getName(),dto.getAge());    
    }
    
    //select 모든 데이터
    public List<CustomDTO> getList(){
        
        StringBuilder sql=new StringBuilder();
            
        sql.append("select id,name,age from custom");
        
        List<CustomDTO> lists=jdbcTemplate.query(sql.toString(), 
                new RowMapper<CustomDTO>() {
 
                    //RowMapper가 while문같은 역할
                    //ResultSet에 select한 결과를 담아서 dto에 반환한다.
                    //그거를 위에 RowMapper<CustomDTO>에 하나씩 담는다.
                    public CustomDTO mapRow(ResultSet rs, int rowNum) throws SQLException {
                        
                        CustomDTO dto=new CustomDTO();
                        
                        dto.setId(rs.getInt("id")); 
                        dto.setName(rs.getString("name"));
                        dto.setAge(rs.getInt("age"));
                    
                        return dto;
                    }            
        });
        
        return lists;    
    }
    
    //select 1개의 데이터
    public CustomDTO getReadData(int id){
        StringBuilder sql=new StringBuilder();
        
        sql.append("select id,name,age from custom where id=?");
        
        CustomDTO dtoOne=jdbcTemplate.queryForObject(sql.toString(),
                new RowMapper<CustomDTO>() {
 
                    public CustomDTO mapRow(ResultSet rs, int rowNum) throws SQLException {
                            
                        CustomDTO dto=new CustomDTO();
                        
                        dto.setId(rs.getInt("id"));
                        dto.setName(rs.getString("name"));
                        dto.setAge(rs.getInt("age"));
                        
                        return dto;
                    }
        },id);
        
        return dtoOne;
    }
    
    //update
    public void updateData(CustomDTO dto) {
 
        StringBuilder sql=new StringBuilder();
            
        sql.append("update custom set name=?,age=? where id=?");
        jdbcTemplate.update(sql.toString(),dto.getName(),dto.getAge(),dto.getId());
    }
    
    //delete
    public void deleteDate(int id) {
 
        StringBuilder sql=new StringBuilder();
        
        sql.append("delete from custom where id=?");
        jdbcTemplate.update(sql.toString(),id);
 
    }
}
cs


-CustomMain.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package com.exe.springjdbctemplate;
 
import java.util.List;
 
import org.springframework.context.support.GenericXmlApplicationContext;
 
public class CustomMain {
 
    public static void main(String[] args) {
        
        GenericXmlApplicationContext context=new GenericXmlApplicationContext("app-context.xml");
        
        CustomDAO2 dao=(CustomDAO2)context.getBean("customDAO2");
        
        CustomDTO dto;
        /*
        dto=new CustomDTO();
        dto.setId(555);
        dto.setName("전정국");
        dto.setAge(23);
        
        dao.insertData(dto);
        
        System.out.println("insert 완료!");
        */
        
        //Oneselect
        dto=dao.getReadData(555);
        
        if(dto!=null) {
            System.out.printf("%d %s %d\n",dto.getId(),dto.getName(),dto.getAge());
        }
        
        System.out.println("OneSelect 완료!");
        
        /*
        //update
        dto = new CustomDTO();
        
        dto.setId(111);
        dto.setName("권지용");
        dto.setAge(22);
        
        dao.updateData(dto);
        
        //delete
        dao.deleteDate(222);
         */
        //select
        List<CustomDTO> lists=dao.getList();
        
        for(CustomDTO dto1:lists) {
            System.out.printf("%d %s %d\n",dto1.getId(),dto1.getName(),dto1.getAge());
        }
        
        System.out.println("select 완료!");
    }
}
cs


-실행화면




4. Spring JDBC 중 NamedParameterJdbcTemplate


-app-context.xml에 추가

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
    <!-- Spring JDBC -->
    <bean id="customDAO2" class="com.exe.springjdbctemplate.CustomDAO2">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>
        <property name="namedJdbcTemplate" ref="namedParameterJdbcTemplate"></property><!-- 여기도 추가 -->
    </bean>
    
    <bean id="jdbcTemplate"
    class="org.springframework.jdbc.core.JdbcTemplate">
        <constructor-arg ref="dataSource"/>
    </bean>
    
    <!-- 이 부분!! -->
    <bean id="namedParameterJdbcTemplate"
    class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
        <constructor-arg ref="dataSource"/>
    </bean>
 
    <bean id="dataSource"
    class="org.apache.commons.dbcp.BasicDataSource"
    destroy-method="close"
    p:driverClassName="oracle.jdbc.driver.OracleDriver"
    p:url="jdbc:oracle:thin:@192.168.16.12:1521:TestDB"
    p:username="suzi"
    p:password="a123"
    />
cs

: Spring JDBC를 쓴부분에 named~ 객체를 추가하고 customDAO2에 property(메소드)의 매개변수로 추가해주었다.


-CustomDAO.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
public class CustomDAO2 {
 
    /*
    private JdbcTemplate jdbcTemplate;
    
    //의존성 주입
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate=jdbcTemplate;
    }*/
 
    private NamedParameterJdbcTemplate namedJdbcTemplate;
    
    public void setNamedJdbcTemplate(NamedParameterJdbcTemplate namedJdbcTemplate) {
        this.namedJdbcTemplate=namedJdbcTemplate;
    }
    
    Connection conn=null;
    
    //insert
    public void insertData(CustomDTO dto) {
        
        StringBuilder sql=new StringBuilder();
            
        /*
         * sql.append("insert into custom(id,name,age) values (?,?,?)");
         * jdbcTemplate.update(sql.toString(), dto.getId(),dto.getName(),dto.getAge());
         */
        
        sql.append("insert into custom (id,name,age) values (:id,:name,:age)");
        
        MapSqlParameterSource params=new MapSqlParameterSource();
        params.addValue("id", dto.getId());
        params.addValue("name", dto.getName());
        params.addValue("age", dto.getAge());
        
        namedJdbcTemplate.update(sql.toString(), params);
    }
cs

: 예시로 insert부분만 구현해 보았다.

그냥 Spring JDBC와는 차이점은

NamedParameterJdbcTemplate은 sql문에서 매개변수로 보내줄 때 ?대신 :id, :name 이런 식으로 보내준다.


-CustomMain.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package com.exe.springjdbctemplate;
 
import java.util.List;
 
import org.springframework.context.support.GenericXmlApplicationContext;
 
public class CustomMain {
 
    public static void main(String[] args) {
        
        GenericXmlApplicationContext context=new GenericXmlApplicationContext("app-context.xml");
        
        CustomDAO2 dao=(CustomDAO2)context.getBean("customDAO2");
        
        CustomDTO dto;
 
        //insert
        dto=new CustomDTO();
        dto.setId(444);
        dto.setName("김지은");
        dto.setAge(20);
        
        dao.insertData(dto);
        
        System.out.println("insert 완료!");
 
        //select
        List<CustomDTO> lists=dao.getList();
        
        for(CustomDTO dto1:lists) {
            System.out.printf("%d %s %d\n",dto1.getId(),dto1.getName(),dto1.getAge());
        }
        
        System.out.println("select 완료!");
    }
}
cs


-실행화면


저작자표시 비영리 변경금지 (새창열림)

+ Recent posts

티스토리툴바