1. Mybatis 소개
MyBatis는 일반 SQL 쿼리, 저장 프로 시저 및 고급 매핑을 지원하는 우수한 지속성 계층 프레임 워크입니다.
MyBatis는 거의 모든 JDBC 코드의 수동 설정과 매개 변수 및 결과 세트의 검색 캡슐화를 제거합니다.
MyBatis는 단순한 XML 또는 주석을 사용하여 구성 및 원시 맵핑, 맵핑 인터페이스 및 Java의 Pojos (일반 Old Java Objects)를 데이터베이스의 레코드로 사용할 수 있습니다.
jdbc-> dbutils (자동 캡슐화) -> mybatis-> hibernate
Mybatis는 XML에서 SQL을 작성한 다음 데이터베이스에 액세스합니다.
2. Mybatis를 시작하십시오
2.1. 새로운 Java 프로젝트를 만듭니다
Mybatis 및 MySQL 드라이버 Jar : Mybatis-3.1.1.jar, mysql-connector-java-5.1.7-bin.jar를 추가하십시오
2.2. 새 테이블을 만듭니다
데이터베이스 생성 MyBatis; MyBatis 사용; 테이블 사용자 만들기 (ID int 기본 키 키 키트 auto_increment, 이름 varchar (20), Age int); 사용자에 삽입 (이름, 연령) 값 ( 'tom', 12); 사용자에 삽입 (이름, 연령) 값 ( 'Jack', 11);
2.3. mybatis 구성 파일 conf.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 가장. id = "develop"> <transactionManager type = "jdbc" /> <dataSource type = "pooled"> <property name = "driver"value = "com.mysql.jdbc.driver" /> <property name = "url"value = "jdbc : mysql : // localhost : 3306 /mybatis"<property name = "userame" "userame" " name = "password"value = "root"/> </datasource> </환경> </환경> </configuration>
2.4. 테이블에 해당하는 엔티티 클래스를 정의하십시오
공개 클래스 사용자 {private int id; private string name; private int age; // get, set method}}2.5. 사용자 테이블을 작동하는 SQL 매핑 파일 usermapper.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"><<<<<<<<<1mapper namespace = "com.atguigu.mybatis_test.test1.usermapper"> <select id = "getUser"parametertype = "int"resulttype = "com.atguigu.mybatis_test.test1.user"> select * id =##{id} </select> </mapper>2.6. conf.xml 파일에 usermapper.xml 파일을 등록하십시오
<Mappers> <Mapper resource = "com/atguigu/mybatis_test/test1/usermapper.xml"/> </mappers>
2.7. 쓰기 테스트 코드 : 정의 된 SELECT 문을 실행합니다
공개 클래스 테스트 {public static void main (string [] args)은 ioexception {string resource = "conf.xml"; // myBatis의 구성 파일로드 (관련 매핑 파일도로드) reader = resource.getResourceAsreader (resource); // sqlsessionfactory sessionficory = new를 구축합니다. sqlsessionfactoryBuilder () 빌드 (reader); // 맵핑 파일에서 sql을 실행할 수있는 sqlsessionsqlsession 세션을 만듭니다. sessionFactory.Opensession (); // 맵핑 sql 식별 문자열 문자 string 문 = "com.atguigu.mybatis.bean.usermpper"+"; // execute"; // execute "; // Session.Selectone (Statement, 1); System.out.println (사용자);}}3. 사용자 테이블의 CRUD를 작동합니다
3.1.xml 구현
3.1.1. SQL 매핑 XML 파일 정의 :
<insert id = "insertUser"parametertype = "com.atguigu.ibatis.bean.user"> 사용자에 삽입 (이름, Age) 값 (#{name},#{age}); </insert> <deleteus "parameter -type ="int "> ind = </delete </delete> </delete </delete" parametertype = "com.atguigu.ibatis.bean.user"> 사용자 업데이트 이름 세트 이름 =#{name}, age =#{age} 여기서 id =#{id} </update> <selectUs "parameterType ="int "int"resultType = "com.atguigu.ibatis.bean.user"> 사용자의 select * id =#{id} </select> <select id = "selectallusers"resulttype = "com.atguigu.ibatis.bean.user"> select * from user </select>3.1.2. 이 매핑 파일을 config.xml에 등록하십시오
<mapper resource = "com/atguigu/ibatis/bean/usermapper.xml"/>
3.1.3. Dao에서 호출
공개 사용자 getUserByid (int id) {sqlsession session = sessionfactory.opensession (); user user = session.selectone (uri+". selectuser", id); return user;}3.2. 주석 구현
3.2.1. SQL 매핑의 인터페이스를 정의하십시오
public interface usermapper {@insert ( "사용자 (이름, Age) 삽입 (#{name},#{age})") public int insertUser (user user);@delete ( "id = =#{id}") public int deleteuserbyid (int id);@update ( "Update set set name =#{name},#{{{{name}####### id =##{id} ") public int updateUser (사용자 사용자);@select ("선택 * id =#{id} ") public user getUserById (int id);@select ("select * from user ") public list <useralluser ();}3.2.2. 이 매핑 인터페이스를 구성에 등록하십시오
<맵퍼/>
3.2.3. Dao에서 호출
공개 사용자 getUserById (int id) {sqlsession session = sessionfactory.opensession (); usermapper mapper = session.getMapper (usermpper.class); user user = mappper.getUserById (id); return user;}4. 최적화 할 수있는 여러 장소
4.1. 데이터베이스에 연결하기위한 구성은 속성 파일에 별도로 배치 될 수 있습니다.
## db.properties <br> <properties resource = "db.properties" /> <property name = "driver"value = "$ {driver}" /> <property name = "url"value = "$ {url}" /> <속성 이름 = "username"value = "$ {username}">4.2. 엔티티 클래스의 별칭 정의 및 SQL 매핑 XML 파일의 참조를 단순화합니다.
<faintealiases> <findealias type = "com.atguigu.ibatis.bean.user"alias = "_ user"/> </infealiases>
4.3. SRC에서 Log4J 구성 파일을 추가하여 로그 정보를 인쇄 할 수 있습니다.
1. 항아리 추가 :
log4j-1.2.16.jar
2.1. log4j.properties (방법 1)
log4j.properties, log4j.rootlogger = debug, console#consolelog4j.appender.console = org.apache.log4j.consoleappenderlog4j.appender.layout = org.apache.log4j.patternlayoutlog4j.appender.console.layout.layout.console.console.console.console.console.console.console.console. %-5p [ %C] - %m%nlog4j.logger.java.sql.resultset = infololog4j.logger.org.apache = infololog4j.logger.java.sql.connection = debuglog4j.logger.java.sql.statement = debuglog4j.logger.sql.sql.sql.sql.sql.sql.sql.sql.sql.sql.sql.sql
2.2. log4j.xml (방법 2)
<? xml version = "1.0"encoding = "utf-8"?> <! doctype log4j : configuration system "log4j.dtd"> <log4j : configuration xmlns : log4j = "http://jakarta.apache.org/log4j/"> appender name = "stdout"> value = "%-5p%d {mm-dd hh : mm : ss, ss}%m (%f :%l) /n" /> < /layout> < /appender> <logger name = "java.sql"> <level value = "debug" /> < /logger> <logger name = "org.apache.ibatis"<level value = "> debug". /> < /logger> <root> <레벨 값 = "디버그" /> <Appender-Ref ref = "stdout" /> < /root> < /log4J : configuration>5. 필드 이름과 엔티티 클래스 속성 이름 간의 충돌 해결
5.1. 테이블과 필드를 준비하십시오
테이블 주문 생성 (Order_ID int 기본 키 auto_increment, order_no varchar (20), order_price float); Orders (Order_No, Order_Price) 값 ( 'AAAA', 23); Orders에 삽입 (Order_No, Order_Price) 값 ( 'BBBB', 33); 'CURTER (ORDER_NO, 33); 22);
5.2. 엔티티 클래스를 정의합니다
공개 클래스 주문 {private int id; private string orderno; private float 가격;}5.3. GetOrderByID (ID)의 쿼리 구현 :
방법 1 : SQL 문에서 별명을 정의하십시오
<select id = "selectorder"parametertype = "int"resulttype = "_ order"> Order_id =#{id} </select>의 Order_ID ID, Order_No OrderNo, Order_Price 가격을 선택하십시오.방법 2 : <resultmap>을 통해
< "select"= "selectorderresultmap"parametertype = "int"resultmap = "orderResultMap"> select * select * order_id =#{id} {id} </select> <resultmap type = "_ order"id = "ordresultMap"> <id "id"column = "order_ <result ="result = "result ="result = "result ="orderSultMap. 속성 = "가격"열 = "Order_Price"/> <결과 속성 = "가격"열 = "Order_Price"/> <resultMap>6. 협회 테이블 쿼리 구현
6.1. 일대일 협회
6.1.1. 요구 사항을 제안합니다
클래스 ID (교사와의 정보)를 기반으로 한 쿼리 클래스 정보
6.1.2. 테이블과 데이터를 만듭니다
테이블 교사 생성 (T_ID int 기본 키 AUTO_INCREMENT, T_NAME VARCHER (20)); 테이블 클래스 생성 (C_ID int 기본 키 AUTO_INCREMENT, C_NAME VARCHAR (20), TERCHTER_ID int); ALTER 테이블 클래스 추가 제약 조건 FK_TECHER_ID 외국 키 (Teacher_id) 참조 교사 (T_ID); 교사 (t_name) 값 ( 'ls1'); 교사에 삽입 (t_name) 값 ( 'ls2')에 삽입; 클래스에 삽입 (c_name, teacher_id) 값 ( 'bj_a', 1); 클래스에 삽입 (c_name, teacher_id) 값 ( 'bj_b', 2);
6.1.3. 엔티티 클래스 정의 :
공개 수업 교사 {private int id; private string name;} 공개 수업 수업 {private int id; private string name; 개인 교사 교사;}6.1.4. SQL 매핑 파일 classmapper.xml을 정의하십시오
<! c.teacher_id = t.t_id 및 c.c_id = s.class_id 및 c.c_id = 1-> <select id = "getclass3"parametertype = "int"resultmap = "classresultmap3"> select * select *에서 class c, teacher t. c.c_id =#{id} </select> <resultmap type = "_ classe"id = "classResultMap3"> <id property = "id"column = "c_id"/> <result property = "name"column = "c_id"/> <Association 속성 = "교사"열 = "teacher_id"javatype = "same" "id 속성 ="id 속성 ""id 속성 ". column = "t_name"/> <result property = "name"column = "t_name"/> </assion> <! 중첩 쿼리 : 다른 SQL 매핑 명령문을 실행하여 예상되는 복잡한 유형을 반환합니다 * C_ID = 1 클래스에서 선택 * 선택 * 선택 * 교사에서 t_id = 1 // 1은 이전 쿼리 선택 *에서 얻은 교사의 값입니다. resultmap = "classResultMap4"> select * select * select * select * select * select * select where c_id =#{id} </select> <resultmap type = "_ classe"id = "classResultMap4"> <id 속성 = "id"열 = "c_id"/> <result property = "name"column = "c_name"/> <sociation ""column = "jector" select = "getTeacher2"> </Association> <Collection Property = "학생"Of -Type = "_ 학생"열 = "C_ID"select = "getStudent"> </collection> </resultMap> <select id = "getTeacher2"parameterType = "int"resultType = "_ Teacher"> teplication in {select in}} id = "getStudent"parametertype = "int"resulttype = "_ 학생들"> select s_id id, s_name name where where where_id =#{id} </select>6.1.5. 시험
@testpublic void testoo () {sqlsession sqlsession = factory.opensession (); 클래스 C = sqlsession.selectone ( "com.atguigu.day03_mybatis.test5.oomapper.getClass", 1); system.out.println (c); factory.opensession (); 클래스 c = sqlsession.selectone ( "com.atguigu.day03_mybatis.test5.oomapper.getclass2", 1); system.out.println (c);}6.2. 일대일 협회
6.2.1. 요구 사항을 제안합니다
학생 및 교사를 포함하여 ClassID에 따라 해당 클래스 정보를 쿼리하십시오.
6.2.2. 테이블 및 데이터 작성 :
테이블 학생 (S_ID int 기본 키 auto_increment, s_name varchar (20), class_id int); 학생 (s_name, class_id) 값 ( 'xs_a', 1); 학생에 삽입 (s_name, class_id) 값 ( 'xs_b', 1); Student (s_name, class_id) 값 ( 'xs_c'; 학생 (s_name, class_id) 값 ( 'xs_d', 2); 학생 (s_name, class_id) 값 ( 'xs_e', 2)에 삽입; 학생 (s_name, class_id) 값 ( 'xs_f', 2);
6.2.3. 엔티티 클래스를 정의합니다
공개 클래스 학생 {private int id; private string name;} 공개 수업 수업 {private int id; private string name; 사립 교사; 개인 목록 <학생> 학생;}6.2.4. SQL 매핑 파일 classmapper.xml을 정의하십시오
<! c.teacher_id = t.t_id 및 c.c_id = s.class_id 및 c.c_id = 1-> <select id = "getclass3"parametertype = "int"resultmap = "classresultmap3"> select * select *에서 class c, teacher t. c.c_id =#{id} </select> <resultmap type = "_ classe"id = "classResultMap3"> <id property = "id"column = "c_id"/> <result property = "name"column = "c_id"/> <Association 속성 = "교사"열 = "teacher_id"javatype = "same" "id 속성 ="id 속성 ""id 속성 ". column = "t_name"/> <result property = "name"column = "t_name"/> </assion> <! 중첩 쿼리 : 다른 SQL 매핑 명령문을 실행하여 예상되는 복잡한 유형을 반환합니다 * C_ID = 1 클래스에서 선택 * 선택 * 선택 * 교사에서 t_id = 1 // 1은 이전 쿼리 선택 *에서 얻은 교사의 값입니다. resultmap = "classResultMap4"> select * select * select * select * select * select * select where c_id =#{id} </select> <resultmap type = "_ classe"id = "classResultMap4"> <id 속성 = "id"열 = "c_id"/> <result property = "name"column = "c_name"/> <sociation ""column = "jector" select = "getTeacher2"> </Association> <Collection Property = "학생"Of -Type = "_ 학생"열 = "C_ID"select = "getStudent"> </collection> </resultMap> <select id = "getTeacher2"parameterType = "int"resultType = "_ Teacher"> teplication in {select in}} id = "getStudent"parametertype = "int"resulttype = "_ 학생들"> select s_id id, s_name name where where where_id =#{id} </select>6.2.5. 시험
@testpublic void testom () {sqlsession sqlsession = factory.opensession (); 클래스 C = sqlsession.selectone ( "com.atguigu.day03_mybatis.test5.oomapper.getClass3", 1); system.out.println (c); factory.opensession (); 클래스 c = sqlsession.selectone ( "com.atguigu.day03_mybatis.test5.oomapper.getclass4", 1); System.out.println (c);}7. 동적 SQL 및 퍼지 쿼리
7.1. 요구 사항
다중 조건 쿼리 사용자 (이름 퍼지 매칭, 지정된 최소값과 최대 값 사이의 연령)를 구현하십시오.
7.2. 데이터베이스 및 테이블을 준비하십시오
테이블 D_USER (ID int 기본 키 AUTO_INCREMENT, 이름 VARCHAR (10), age int (3)); d_user (이름, 연령) 값 ( 'Tom', 12)에 삽입; d_user (이름, 연령) 값에 삽입 ( 'bob', 13); d_user (이름, 연령) 값 ( 'Jack', 18); 7.3.conditionUser (쿼리 조건부 엔티티 클래스) 개인 문자열 이름; private int minage; private int maxage;
7.4. 사용자 테이블 엔티티 클래스
개인 int id; 개인 문자열 이름; 개인 int 연령;
7.5.usermapper.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.atguigu.day03_mybatis.test6.usermapper"> <select id = "getUser"parameterType = "com.atguigu.day03_mybatis.test6.conditionUser"resultType = "com.atguigu.day03_mybatis.test6.user"> select * from d_user " age> =#{minage} 및 age <=#{maxage} <if test = 'name! = "%null%"'> 및#{name}와 같은 이름 </if> </select> </mapper>7.6.usertest (테스트)
public class usertest {public static void main (string [] args)은 ioexception {reader reader = resources.getresourceasreader ( "conf.xml"); sqlsessionfactory sessionfactory = new sqlsessionfactorybuilder (). build (reader); sqlsessions sqlsessionsessions (stistion statectory.opensession). "com.atguigu.day03_mybatis.test6.usermapper.getUser"; list <user> list = sqlsession.selectList (state, new 컨디셔너 ( "%a%", 1, 12)); System.out.println (list);}}MyBatis에서 사용 가능한 동적 SQL 태그
8. 저장된 절차 호출
8.1. 요구하십시오
수신이 0 인 경우 남성 또는 여성의 수를 쿼리하십시오. 그렇지 않으면 남성은 남성입니다.
8.2. 데이터베이스 테이블 및 저장된 절차 준비 :
테이블 P_USER (ID int 기본 키 AUTO_INCREMENT, 이름 VARCHAR (10), 섹스 char (2)); p_user (이름, 섹스) 값 ( 'a', "male")에 삽입; p_user (이름, 섹스) 값 ( 'b', "female")에 삽입; p_user (이름, 섹스) 값 ( 'c', "male")에 삽입; #create 저장 절차 (수신이 0 인 경우 남성 또는 여성의 수를 찾으십시오. 암컷은 남성입니다) Delimiter $ Procedure Crome Procedure MyBatis.ges_user_count (sex_id int, out user_count int)는 mybatis.p_user에서 sex_id = 0 thenselect count (*)를 시작합니다. count (*) mybatis.p_user에서 p_user.sex = 'male'in user_count; end if; end $#call 저장 절차 delimiter; set @user_count = 0; call mybatis.ges_user_count (1, @user_count); select @user_count;
8.3. 테이블의 엔티티 클래스를 만듭니다
공개 클래스 사용자 {개인 문자열 ID; 개인 문자열 이름; 개인 문자열 섹스;}8.4.usermapper.xml
<Mapper 네임 스페이스 = "com.atguigu.mybatis.test7.usermapper"> <!-쿼리는 남성 또는 여성의 수를 가져옵니다. 수신이 0 인 경우 암컷은 그렇지 않으면 남성입니다. call mybatis.get_user_count (1, @user_count);-> <select id = "getCount"statementtype = "callable"parametermap = "getCountMap"> Call mybatis.get_user_count (?) id = "getCountMap"> <parameter property = "sex_id"mode = "in"jdbctype = "integer"/<parameter property = "user_count"mode = "out"jdbctype = "integer"// </parametermp> </mapper>
8.5. 시험
map <string, integer> parammap = new Hashmap <> (); Parammap.put ( "sex_id", 0); session.selectone (state, parammap); integer usercount = parammap.get ( "user_count"); system.out.println (usercount);
9. Mybatis 캐시
9.1. mybatis 캐시를 이해하십시오
대부분의 지속성 층 프레임 워크와 마찬가지로 Mybatis는 L1 및 L2 캐시를 지원합니다.
1. 레벨 1 캐시 : Hashmap 로컬 캐시 PerpetualCache를 기반으로 스토리지 범위는 세션입니다. 세션이 플러시되거나 닫히면 세션의 모든 캐시가 지워집니다.
2. 보조 캐시의 메커니즘은 기본 캐시의 메커니즘과 동일합니다. 기본적으로 PerpetualCache 및 Hashmap 스토리지도 사용합니다. 차이점은 스토리지 범위가 Mapper (네임 스페이스)이며 Ehcache와 같은 스토리지 소스를 사용자 정의 할 수 있다는 것입니다.
3. 캐시 데이터 업데이트 메커니즘의 경우 특정 범위 (1 단계 캐시 세션/두 번째 레벨 캐시 네임 스페이스)가 C/U/D 작업에서 수행되면이 스코프의 선택의 모든 캐시는 기본적으로 지워집니다.
9.2. Mybatis 레벨 1 캐시
9.2.1. 작업을 기반으로 한 쿼리
ID를 기반으로 해당 사용자 레코드 객체를 쿼리하십시오.
9.2.2. 데이터베이스 테이블 및 데이터를 준비하십시오
테이블 C_USER (ID int 1 차 키 키 오토 _increment, 이름 varchar (20), age int); c_user (이름, 연령) 값 ( 'tom', 12)에 삽입; c_user (이름, 연령) 값 ( 'Jack', 11)에 삽입;
9.2.3. 테이블의 엔티티 클래스를 만듭니다
공개 클래스 사용자는 직렬화 가능한 {private int id; private string 이름; 개인 int 연령;9.2.4.usermapper.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"><<<<<<<<<1mapper namespace = "com.atguigu.mybatis.test8.usermapper"> <select id = "getUser"parameterType = "int"resultType = "_ cuser"> select *에서 c_user에서 id =#{id} </select> <update id = "updateUser"parameterType = "_ cuser"> setname =######### age =#{age} id =#{id} </update> </mapper>9.2.5. 테스트
/** 레벨 1 캐시 : 즉, 세션 수준 캐시 (기본적으로)*/@testpublic void testCache1 () {sqlsession session = myBatisutils.getSession (); String 문 = "com.atguigu.mybatis.test8.usermpaper.getUser"; user user = session.selectone (state, 1); 시스템, 1); 1 캐시는 기본적으로*//*user = session.selectone (state, 1); System.out.println (사용자);*//*1을 사용합니다. 같은 세션이어야합니다. 세션 객체가 닫힌 경우 ()를 사용하는 경우*//*세션 = mybatisutils.getSession (); user = session.selectone (state, 1); system.out.println (user);*//*2. 쿼리 조건은 동일합니다*//*user = session.selectone (Statement, 2); System.out.println (사용자);*//*3. Session.clearCache ()는 캐시를 청소하기 위해 실행되지 않았습니다.*//*session.clearCache (); user = session.selectone (state, 2); System.out.println (user);*//*4. 추가, 삭제 및 수정 된 작업이 없음 (이 작업은 캐시를 정리합니다)*//*session.update ( "com.atguigu.mybatis.test8.usermapper.updateuser", 새 사용자 (2, "사용자", 23); user = session.selectone (state, 2); system.out.println (user);*/};9.3. 3. Mybatis 레벨 2 캐시
9.3.1. usermapper.xml에 <cache>를 추가하십시오
<mapper 네임 스페이스 = "com.atguigu.mybatis.test8.usermapper"> <cache/>
9.3.2. 테스트
/** 테스트 레벨 2 캐시*/@testpublic void testCache2 () {string statement = "com.atguigu.mybatis.test8.usermapper.getUser"; sqlsession session = myBatisutils.getSession (); user user = session.selectone (state, 1); session.commit (); System.out.out.out.out.out.out.out.out.out.out. session2 = mybatisutils.getSession (); user = session2.selectone (state, 1); session.commit (); system.out.println ( "user2 ="+user);}9.3.3. 보충 메모
1. 매핑 명령문 파일의 모든 선택 문은 캐시됩니다.
2. 문에서 모든 삽입, 업데이트 및 삭제 된 문장 파일에서 캐시가 새로 고침됩니다.
3. 캐시는 가장 최근에 사용 된 LRU (최근에 가장 적은 최소 사용) 알고리즘을 사용하여 재조정됩니다.
4. 지정된 시간 간격에 따라 캐시가 새로 고침됩니다.
5. 캐시는 1024 개 객체를 저장합니다
<cacheeviction = "fifo"// 재활용 전략은 우선, First-Out FlushInterval = "60000"// 자동 새로 고침 시간 60SSize = "512"// 512 참조 객체 readOnly = "true"// 읽기 만 해당됩니다.
10. 스프링 통합 mybatis
10.1. 항아리를 추가하십시오
【mybatis b
Mybatis-3.2.0.jar
Mybatis-Spring-1.1.1.jar
log4j-1.2.17.jar
【봄】
Spring-Aop-3.2.0. Release.jar
Spring-Beans-3.2.0. Release.jar
Spring-Context-3.2.0.Release.jar
스프링 코어 -3.2.0. Release.jar
Spring-Expression-3.2.0. Release.jar
Spring-jdbc-3.2.0.release.jar
스프링 테스트 -3.2.4. Release.jar
Spring-TX-3.2.0.Release.jar
aopalliance-1.0.jar
cglib-nodep-2.2.3.jar
커먼즈-로깅 1.1.1.jar
MySQL 드라이버 패키지】
MySQL-Connector-Java-5.0.4-bin.jar
10.2. 데이터베이스 테이블
테이블 생성 s_user (user_id int auto_increment 기본 키, user_name varchar (30), user_birthday 날짜, user_salary double)
10.3. 엔티티 클래스 : 사용자
공개 클래스 사용자 {private int id; 개인 문자열 이름; 개인 날짜 생일; 개인 이중 급여; // set, get method}}10.4.dao 인터페이스 : usermapper (xxxmapper)
public interface usermapper {void save (user user); void update (user user); void delete (int id); user findbyid (int id); list <user> findall ();}10.5.sql 매핑 파일 : usermapper.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.atguigu.mybatis.test9.usermapper"> <resultmap type = "user"id = "userresult"> <result column = "user_id"property = "id"/> <결과 열 = "user_name"속성 = "name"/> <result column = "user_birthday"property "introspory"result column = "result colmp" column = "user_salary"property = "salary"/> <resultmap> <!-데이터를 삽입 한 후 ID를 가져옵니다-> <insert id = "save"keycolumn = "user_id"keyproperty = "id"usegeneratedkeys = "true"> 삽입 s_user (user_name, user_birthday, user_salary) 값 ( #{name}, #{생일}, #{Salary}) </insert> <Update id = "update"> update s_userset user_name = #{name}, user_birthday = {생일}, user_salary = #{user} #{id} </update> <delete id = "delete"> s_userwhere user_id = #{id} </delete> < "findById"resultmap = "userresult"> select *에서 select *{id} </select> <select id = "findall"resultmap = "selects" s_user </select> </mapper>10.6. 스프링 구성 파일 : beans.xml
<? xml 버전 = "1.0"encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans"xmlns : xsi = "http://www.w3.org/2001/xmlschema-instance"xmlns : p = "http://www.springframwork.org/schema/p "Xmlns : context ="http://www.springframework.org/schema/context "xmlns : tx ="http://www.springframework.org/schema/tx "xsi : schemalocation ="http : //www.springfr amework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.2.xsdhttp://www.springframework.org/schema/context/sprin g-context-3.2.xsdhttp : //www.springframework.org/schema/schema/spring-33.2.xsdhttp : //www.springframework.org/schema/tx/spring-tx-3.2.xsd ">- 1. 데이터 출처 : DriverManagerDatasource-> <Bean id = "DataSource"class = "org.springframework.jdbc.datasource.driverManagerDatasource"> <property name = "value ="com.mysql.jdbc.driver "/> <url" value = "jdbc : mysql : // localhost : 3306/mybatis"/> <property name = "username"value = "root"/<property name = "password"value = "root"/> </bean> <!-2. MyBatis 'Sqlsession Factory : SQLSESSIONFACTORYBEANDATASOURCE/intealiasSpackage-> <bean id = "sqlSessionFactory"> <property name = "dataSource"ref = "dataSource"/> <property name = "glantealiasespackage"value = "com.atigu.sprring_mybatis2. MyBatis는 SQL 매핑 파일을로드하기 위해 자동으로 스캔합니다. MapperscannerConconfigurersqlSessionFactory/BasePackage-> <ean> <속성 이름 = "BasePackage"value = "com.atigu.spring_mybatis2.mapper"/> <sqlsessionfactory "ref ="sqlsessionation "/>-4. DataSourCetransactionManager--> <bean id = "txmanager"> <property name = "dataSource"ref = "dataSource"/> </bean> <!-5. 선언 트랜잭션 사용-> <tx : 주석 중심 트랜잭션-매너 = "txmanager"/> </bean>
10.7.myBatis 구성 파일 : mybatis-config.xml
<? xml version = "1.0"encoding = "utf-8"?> <! doctype configurationpublic "-// mybatis.org//dtd config 3.0 // en" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <! 불필요한-> <!-외부 구성 파일 설정-> <!-카테고리 이름 설정-> <!-데이터베이스 연결 환경 설정-> <!-매핑 파일-> </configuration>
10.8. 시험
@RunWith (SpringJunit4classRunner.class) // SpringTest 테스트 프레임 워크 @ContextConfiguration ( "/beans.xml") // 부하 구성 공개 클래스 smtest {@autowired // 개인 usermapper usermapper; @testpublic void save () {user user (); user.set birthday (); date ()); user.setName ( "mary"); user.setSalary (300); usermapper.save (user); system.out.println (user.getid ());}@testpublic void update () {usermapper.findbyid (2); user.setsalary (2000); usermapper.update (usermapper.update); {usermapper.delete (3);}@testpublic void findByid () {user user = usermapper.findbyid (1); system.out.println (user);}@testpublic void findall () {user> user = usermapper.findall (); system.out.println (users);}}위의 것은 편집자가 소개 한 Mybatis (간단하고 간단한 분석 및 이해하기 쉬운)에 대한 빠른 소개입니다. 모든 사람에게 도움이되기를 바랍니다. 궁금한 점이 있으면 메시지를 남겨 주시면 편집자가 제 시간에 모든 사람에게 답장을 드리겠습니다. Wulin.com 웹 사이트를 지원해 주셔서 대단히 감사합니다!