mybatis學習記錄
轉自：http://www.yihaomen.com/article/java/302.htmhtml
（讀者注：其實這個應該叫作很基礎的入門一下下，若是你看過Hibernate了那這個就很是的簡單）java
（再加一條，其實你們能夠看官方的教程更好些：http://mybatis.github.io/mybatis-3/，並且若是英文不是很好的那就看中文的：http://mybatis.github.io/mybatis-3/zh/sqlmap-xml.html）mysql
寫在這個系列前面的話:git
之前曾經用過ibatis,這是mybatis的前身，當時在作項目時，感受很不錯，比hibernate靈活。性能也比hibernate好。並且也比較輕量級，由於當時在項目中，沒來的及作很不少筆記。後來項目結束了，我也沒寫總結文檔。已通過去很久了。但最近忽然又對這個ORM 工具感興趣。由於接下來本身的項目中頗有可能採用這個ORM工具。因此在此從新溫習了一下 mybatis, 所以就有了這個系列的 mybatis 教程.
什麼是mybatis
MyBatis是支持普通SQL查詢，存儲過程和高級映射的優秀持久層框架。MyBatis消除了幾乎全部的JDBC代碼和參數的手工設置以及結果集的檢索。MyBatis使用簡單的XML或註解用於配置和原始映射，將接口和Java的POJOs（Plan Old Java Objects，普通的Java對象）映射成數據庫中的記錄.
orm工具的基本思想
不管是用過的hibernate,mybatis,你均可以法相他們有一個共同點：
1. 從配置文件(一般是XML配置文件中)獲得 sessionfactory.
2. 由sessionfactory 產生 session
3. 在session 中完成對數據的增刪改查和事務提交等.
4. 在用完以後關閉session 。github
5. 在java 對象和 數據庫之間有作mapping 的配置文件，也一般是xml 文件。web
mybatis實戰教程(mybatis in action)之一：開發環境搭建
mybatis 的開發環境搭建，選擇: eclipse j2ee 版本，mysql 5.1 ,jdk 1.7,mybatis3.2.0.jar包。這些軟件工具都可以到各自的官方網站上下載。
首先創建一個名字爲 MyBaits 的 dynamic web project
1. 現階段，你能夠直接創建java 工程，但通常都是開發web項目，這個系列教程最後也是web的，因此一開始就創建web工程。
2. 將 mybatis-3.2.0-SNAPSHOT.jar，mysql-connector-java-5.1.22-bin.jar 拷貝到 web工程的lib目錄.
3. 建立mysql 測試數據庫和用戶表,注意，這裏採用的是 utf-8 編碼
建立用戶表,並插入一條測試數據
程序代碼
Create TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`userName` varchar(50) DEFAULT NULL,
`userAge` int(11) DEFAULT NULL,
`userAddress` varchar(200) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
Insert INTO `user` VALUES ('1', 'summer', '100', 'shanghai,pudong');
到此爲止，前期準備工做就完成了。下面開始真正配置mybatis項目了。
1. 在MyBatis 裏面建立兩個源碼目錄，分別爲 src_user,test_src, 用以下方式創建,鼠標右鍵點擊 JavaResource.
2. 設置mybatis 配置文件:Configuration.xml, 在src_user目錄下創建此文件，內容以下:
程序代碼
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
" http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<typeAliases>
<typeAlias alias="User" type="com.yihaomen.mybatis.model.User"/>
</typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis" />
<property name="username" value="root"/>
<property name="password" value="password"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="com/yihaomen/mybatis/model/User.xml"/>
</mappers>
</configuration>
3. 創建與數據庫對應的 java class,以及映射文件.
在src_user下創建package:com.yihaomen.mybatis.model ,並在這個 package 下創建 User 類:
程序代碼
package com.yihaomen.mybatis.model;
public class User {
private int id;
private String userName;
private String userAge;
private String userAddress;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getUserAge() {
return userAge;
}
public void setUserAge(String userAge) {
this.userAge = userAge;
}
public String getUserAddress() {
return userAddress;
}
public void setUserAddress(String userAddress) {
this.userAddress = userAddress;
}
}
同時創建這個User 的映射文件 User.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.yihaomen.mybatis.models.UserMapper">
<select id="selectUserByID" parameterType="int" resultType="User">
select * from `user` where id = #{id}
</select>
</mapper>
下面對這幾個配置文件解釋下：
1.Configuration.xml 是 mybatis 用來創建 sessionFactory 用的，裏面主要包含了數據庫鏈接相關東西，還有 java 類所對應的別名，好比 <typeAlias alias="User" type="com.yihaomen.mybatis.model.User"/> 這個別名很是重要，你在 具體的類的映射中，好比User.xml 中 resultType 就是對應這裏的。要保持一致，固然這裏的 resultType 還有另外單獨的定義方式，後面再說。
2. Configuration.xml 裏面 的<mapper resource="com/yihaomen/mybatis/model/User.xml"/>是包含要映射的類的xml配置文件。
3. 在User.xml 文件裏面 主要是定義各類SQL 語句，以及這些語句的參數，以及要返回的類型等.
開始測試
在test_src 源碼目錄下創建com.yihaomen.test這個package,並創建測試類Test:
程序代碼
package com.yihaomen.test;
import java.io.Reader;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import com.yihaomen.mybatis.model.User;
public class Test {
private static SqlSessionFactory sqlSessionFactory;
private static Reader reader;
static{
try{
reader = Resources.getResourceAsReader("Configuration.xml");
sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
}catch(Exception e){
e.printStackTrace();
}
}
public static SqlSessionFactory getSession(){
return sqlSessionFactory;
}
public static void main(String[] args) {
SqlSession session = sqlSessionFactory.openSession();
try {
User user = (User) session.selectOne("com.yihaomen.mybatis.models.UserMapper.selectUserByID", 1);
System.out.println(user.getUserAddress());
System.out.println(user.getUserName());
} finally {
session.close();
}
}
}
如今運行這個程序，是否是獲得查詢結果了。恭喜你，環境搭建配置成功，接下來第二章，將講述基於接口的操做方式，增刪改查。
整個工程目錄結構以下:
首先創建一個名字爲 MyBaits 的 dynamic web project
1. 現階段，你能夠直接創建java 工程，但通常都是開發web項目，這個系列教程最後也是web的，因此一開始就創建web工程。
2. 將 mybatis-3.2.0-SNAPSHOT.jar，mysql-connector-java-5.1.22-bin.jar 拷貝到 web工程的lib目錄.
3. 建立mysql 測試數據庫和用戶表,注意，這裏採用的是 utf-8 編碼
建立用戶表,並插入一條測試數據
程序代碼
Create TABLE `user` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`userName` varchar(50) DEFAULT NULL,
`userAge` int(11) DEFAULT NULL,
`userAddress` varchar(200) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
Insert INTO `user` VALUES ('1', 'summer', '100', 'shanghai,pudong');
到此爲止，前期準備工做就完成了。下面開始真正配置mybatis項目了。
1. 在MyBatis 裏面建立兩個源碼目錄，分別爲 src_user,test_src, 用以下方式創建,鼠標右鍵點擊 JavaResource.
2. 設置mybatis 配置文件:Configuration.xml, 在src_user目錄下創建此文件，內容以下:
程序代碼
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
" http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<typeAliases>
<typeAlias alias="User" type="com.yihaomen.mybatis.model.User"/>
</typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis" />
<property name="username" value="root"/>
<property name="password" value="password"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="com/yihaomen/mybatis/model/User.xml"/>
</mappers>
</configuration>
3. 創建與數據庫對應的 java class,以及映射文件.
在src_user下創建package:com.yihaomen.mybatis.model ,並在這個 package 下創建 User 類:
程序代碼
package com.yihaomen.mybatis.model;
public class User {
private int id;
private String userName;
private String userAge;
private String userAddress;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getUserAge() {
return userAge;
}
public void setUserAge(String userAge) {
this.userAge = userAge;
}
public String getUserAddress() {
return userAddress;
}
public void setUserAddress(String userAddress) {
this.userAddress = userAddress;
}
}
同時創建這個User 的映射文件 User.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.yihaomen.mybatis.models.UserMapper">
<select id="selectUserByID" parameterType="int" resultType="User">
select * from `user` where id = #{id}
</select>
</mapper>
下面對這幾個配置文件解釋下：
1.Configuration.xml 是 mybatis 用來創建 sessionFactory 用的，裏面主要包含了數據庫鏈接相關東西，還有 java 類所對應的別名，好比 <typeAlias alias="User" type="com.yihaomen.mybatis.model.User"/> 這個別名很是重要，你在 具體的類的映射中，好比User.xml 中 resultType 就是對應這裏的。要保持一致，固然這裏的 resultType 還有另外單獨的定義方式，後面再說。
2. Configuration.xml 裏面 的<mapper resource="com/yihaomen/mybatis/model/User.xml"/>是包含要映射的類的xml配置文件。
3. 在User.xml 文件裏面 主要是定義各類SQL 語句，以及這些語句的參數，以及要返回的類型等.
開始測試
在test_src 源碼目錄下創建com.yihaomen.test這個package,並創建測試類Test:
程序代碼
package com.yihaomen.test;
import java.io.Reader;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import com.yihaomen.mybatis.model.User;
public class Test {
private static SqlSessionFactory sqlSessionFactory;
private static Reader reader;
static{
try{
reader = Resources.getResourceAsReader("Configuration.xml");
sqlSessionFactory = new SqlSessionFactoryBuilder().build(reader);
}catch(Exception e){
e.printStackTrace();
}
}
public static SqlSessionFactory getSession(){
return sqlSessionFactory;
}
public static void main(String[] args) {
SqlSession session = sqlSessionFactory.openSession();
try {
User user = (User) session.selectOne("com.yihaomen.mybatis.models.UserMapper.selectUserByID", 1);
System.out.println(user.getUserAddress());
System.out.println(user.getUserName());
} finally {
session.close();
}
}
}
如今運行這個程序，是否是獲得查詢結果了。恭喜你，環境搭建配置成功，接下來第二章，將講述基於接口的操做方式，增刪改查。
整個工程目錄結構以下:
除非申明,文章均爲
一號門原創,轉載請註明本文地址,謝謝!
前面一章，已經搭建好了eclipse,mybatis,mysql的環境，而且實現了一個簡單的查詢。請注意，這種方式是用SqlSession實例來直接執行已映射的SQL語句：
session.selectOne("com.yihaomen.mybatis.models.UserMapper.selectUserByID", 1)
其實還有更簡單的方法，並且是更好的方法，使用合理描述參數和SQL語句返回值的接口（好比IUserOperation.class），這樣如今就能夠至此那個更簡單，更安全的代碼，沒有容易發生的字符串文字和轉換的錯誤.下面是詳細過程:
在src_user源碼目錄下創建 com.yihaomen.mybatis.inter 這個包，並創建接口類 IUserOperation , 內容以下：
程序代碼
package com.yihaomen.mybatis.inter;
import com.yihaomen.mybatis.model.User;
public interface IUserOperation {
public User selectUserByID(int id);
}
請注意，這裏面有一個方法名 selectUserByID 必須與 User.xml 裏面配置的 select 的id 對應（<select id="selectUserByID"）
重寫測試代碼
程序代碼
public static void main(String[] args) {
SqlSession session = sqlSessionFactory.openSession();
try {
IUserOperation userOperation=session.getMapper(IUserOperation.class);
User user = userOperation.selectUserByID(1);
System.out.println(user.getUserAddress());
System.out.println(user.getUserName());
} finally {
session.close();
}
}
整個工程結構圖如今以下：
這種方式，要注意的一個地方就是。在User.xml 的配置文件中，mapper namespace="com.yihaomen.mybatis.inter.IUserOperation" ，命名空間很是重要，不能有錯，必須與咱們定義的package 和 接口一致。
session.selectOne("com.yihaomen.mybatis.models.UserMapper.selectUserByID", 1)
其實還有更簡單的方法，並且是更好的方法，使用合理描述參數和SQL語句返回值的接口（好比IUserOperation.class），這樣如今就能夠至此那個更簡單，更安全的代碼，沒有容易發生的字符串文字和轉換的錯誤.下面是詳細過程:
在src_user源碼目錄下創建 com.yihaomen.mybatis.inter 這個包，並創建接口類 IUserOperation , 內容以下：
程序代碼
package com.yihaomen.mybatis.inter;
import com.yihaomen.mybatis.model.User;
public interface IUserOperation {
public User selectUserByID(int id);
}
請注意，這裏面有一個方法名 selectUserByID 必須與 User.xml 裏面配置的 select 的id 對應（<select id="selectUserByID"）
重寫測試代碼
程序代碼
public static void main(String[] args) {
SqlSession session = sqlSessionFactory.openSession();
try {
IUserOperation userOperation=session.getMapper(IUserOperation.class);
User user = userOperation.selectUserByID(1);
System.out.println(user.getUserAddress());
System.out.println(user.getUserName());
} finally {
session.close();
}
}
整個工程結構圖如今以下：
這種方式，要注意的一個地方就是。在User.xml 的配置文件中，mapper namespace="com.yihaomen.mybatis.inter.IUserOperation" ，命名空間很是重要，不能有錯，必須與咱們定義的package 和 接口一致。
前面已經講到用接口的方式編程。若是不一致就會出錯,這一章主要在上一講基於接口編程的基礎上完成以下事情:
1. 用 mybatis 查詢數據，包括列表
2. 用 mybatis 增長數據
3. 用 mybatis 更新數據.
4. 用 mybatis 刪除數據.
查詢數據，前面已經講過簡單的，主要看查詢出列表的
查詢出列表，也就是返回list, 在咱們這個例子中也就是 List<User> , 這種方式返回數據，須要在User.xml 裏面配置返回的類型 resultMap, 注意不是 resultType, 而這個resultMap 所對應的應該是咱們本身配置的
程序代碼
<!-- 爲了返回list 類型而定義的returnMap -->
<resultMap type="User" id="resultListUser">
<id column="id" property="id" />
<result column="userName" property="userName" />
<result column="userAge" property="userAge" />
<result column="userAddress" property="userAddress" />
</resultMap>
查詢列表的語句在 User.xml 中
程序代碼
<!-- 返回list 的select 語句，注意 resultMap 的值是指向前面定義好的 -->
<select id="selectUsers" parameterType="string" resultMap="resultListUser">
select * from user where userName like #{userName}
</select>
在 IUserOperation 接口中增長方法：public List<User> selectUsers(String userName);
如今在 Test 類中作測試
程序代碼
public void getUserList(String userName){
SqlSession session = sqlSessionFactory.openSession();
try {
IUserOperation userOperation=session.getMapper(IUserOperation.class);
List<User> users = userOperation.selectUsers(userName);
for(User user:users){
System.out.println(user.getId()+":"+user.getUserName()+":"+user.getUserAddress());
}
} finally {
session.close();
}
}
如今在main 方法中能夠測試：
程序代碼
public static void main(String[] args) {
Test testUser=new Test();
testUser.getUserList("%");
}
能夠看到，結果成功查詢出來。若是是查詢單個數據的話，用第二講用過的方法就能夠了。
用mybatis 增長數據
在 IUserOperation 接口中增長方法：public void addUser(User user);
在 User.xml 中配置
程序代碼
<!--執行增長操做的SQL語句。id和parameterType
分別與IUserOperation接口中的addUser方法的名字和
參數類型一致。以#{name}的形式引用Student參數
的name屬性，MyBatis將使用反射讀取Student參數
的此屬性。#{name}中name大小寫敏感。引用其餘
的gender等屬性與此一致。seGeneratedKeys設置
爲"true"代表要MyBatis獲取由數據庫自動生成的主
鍵；keyProperty="id"指定把獲取到的主鍵值注入
到Student的id屬性-->
<insert id="addUser" parameterType="User"
useGeneratedKeys="true" keyProperty="id">
insert into user(userName,userAge,userAddress)
values(#{userName},#{userAge},#{userAddress})
</insert>
而後在 Test 中寫測試方法:
程序代碼
/**
* 測試增長,增長後，必須提交事務，不然不會寫入到數據庫.
*/
public void addUser(){
User user=new User();
user.setUserAddress("人民廣場");
user.setUserName("飛鳥");
user.setUserAge(80);
SqlSession session = sqlSessionFactory.openSession();
try {
IUserOperation userOperation=session.getMapper(IUserOperation.class);
userOperation.addUser(user);
session.commit();
System.out.println("當前增長的用戶 id爲:"+user.getId());
} finally {
session.close();
}
}
用mybatis 更新數據
方法相似，先在 IUserOperation 中增長方法：public void addUser(User user);
而後配置 User.xml
程序代碼
<update id="updateUser" parameterType="User" >
update user set userName=#{userName},userAge=#{userAge},userAddress=#{userAddress} where id=#{id}
</update>
Test 類總的測試方法以下：
程序代碼
public void updateUser(){
//先獲得用戶,而後修改，提交。
SqlSession session = sqlSessionFactory.openSession();
try {
IUserOperation userOperation=session.getMapper(IUserOperation.class);
User user = userOperation.selectUserByID(4);
user.setUserAddress("原來是魔都的浦東創新園區");
userOperation.updateUser(user);
session.commit();
} finally {
session.close();
}
}
用mybatis 刪除數據
同理，IUserOperation 增長方法：public void deleteUser(int id);
配置User.xml
程序代碼
<delete id="deleteUser" parameterType="int">
delete from user where id=#{id}
</delete>
而後在Test類中寫測試方法:
程序代碼
/**
* 刪除數據，刪除必定要 commit.
* @param id
*/
public void deleteUser(int id){
SqlSession session = sqlSessionFactory.openSession();
try {
IUserOperation userOperation=session.getMapper(IUserOperation.class);
userOperation.deleteUser(id);
session.commit();
} finally {
session.close();
}
}
這樣，全部增刪改查都完成了，注意在增長，更改，刪除的時候要調用session.commit()，這樣纔會真正對數據庫進行操做，不然是沒有提交的。
到此爲止，簡單的單表操做，應該都會了，接下來的時間了，我會講多表聯合查詢，以及結果集的選取。
1. 用 mybatis 查詢數據，包括列表
2. 用 mybatis 增長數據
3. 用 mybatis 更新數據.
4. 用 mybatis 刪除數據.
查詢數據，前面已經講過簡單的，主要看查詢出列表的
查詢出列表，也就是返回list, 在咱們這個例子中也就是 List<User> , 這種方式返回數據，須要在User.xml 裏面配置返回的類型 resultMap, 注意不是 resultType, 而這個resultMap 所對應的應該是咱們本身配置的
程序代碼
<!-- 爲了返回list 類型而定義的returnMap -->
<resultMap type="User" id="resultListUser">
<id column="id" property="id" />
<result column="userName" property="userName" />
<result column="userAge" property="userAge" />
<result column="userAddress" property="userAddress" />
</resultMap>
查詢列表的語句在 User.xml 中
程序代碼
<!-- 返回list 的select 語句，注意 resultMap 的值是指向前面定義好的 -->
<select id="selectUsers" parameterType="string" resultMap="resultListUser">
select * from user where userName like #{userName}
</select>
在 IUserOperation 接口中增長方法：public List<User> selectUsers(String userName);
如今在 Test 類中作測試
程序代碼
public void getUserList(String userName){
SqlSession session = sqlSessionFactory.openSession();
try {
IUserOperation userOperation=session.getMapper(IUserOperation.class);
List<User> users = userOperation.selectUsers(userName);
for(User user:users){
System.out.println(user.getId()+":"+user.getUserName()+":"+user.getUserAddress());
}
} finally {
session.close();
}
}
如今在main 方法中能夠測試：
程序代碼
public static void main(String[] args) {
Test testUser=new Test();
testUser.getUserList("%");
}
能夠看到，結果成功查詢出來。若是是查詢單個數據的話，用第二講用過的方法就能夠了。
用mybatis 增長數據
在 IUserOperation 接口中增長方法：public void addUser(User user);
在 User.xml 中配置
程序代碼
<!--執行增長操做的SQL語句。id和parameterType
分別與IUserOperation接口中的addUser方法的名字和
參數類型一致。以#{name}的形式引用Student參數
的name屬性，MyBatis將使用反射讀取Student參數
的此屬性。#{name}中name大小寫敏感。引用其餘
的gender等屬性與此一致。seGeneratedKeys設置
爲"true"代表要MyBatis獲取由數據庫自動生成的主
鍵；keyProperty="id"指定把獲取到的主鍵值注入
到Student的id屬性-->
<insert id="addUser" parameterType="User"
useGeneratedKeys="true" keyProperty="id">
insert into user(userName,userAge,userAddress)
values(#{userName},#{userAge},#{userAddress})
</insert>
而後在 Test 中寫測試方法:
程序代碼
/**
* 測試增長,增長後，必須提交事務，不然不會寫入到數據庫.
*/
public void addUser(){
User user=new User();
user.setUserAddress("人民廣場");
user.setUserName("飛鳥");
user.setUserAge(80);
SqlSession session = sqlSessionFactory.openSession();
try {
IUserOperation userOperation=session.getMapper(IUserOperation.class);
userOperation.addUser(user);
session.commit();
System.out.println("當前增長的用戶 id爲:"+user.getId());
} finally {
session.close();
}
}
用mybatis 更新數據
方法相似，先在 IUserOperation 中增長方法：public void addUser(User user);
而後配置 User.xml
程序代碼
<update id="updateUser" parameterType="User" >
update user set userName=#{userName},userAge=#{userAge},userAddress=#{userAddress} where id=#{id}
</update>
Test 類總的測試方法以下：
程序代碼
public void updateUser(){
//先獲得用戶,而後修改，提交。
SqlSession session = sqlSessionFactory.openSession();
try {
IUserOperation userOperation=session.getMapper(IUserOperation.class);
User user = userOperation.selectUserByID(4);
user.setUserAddress("原來是魔都的浦東創新園區");
userOperation.updateUser(user);
session.commit();
} finally {
session.close();
}
}
用mybatis 刪除數據
同理，IUserOperation 增長方法：public void deleteUser(int id);
配置User.xml
程序代碼
<delete id="deleteUser" parameterType="int">
delete from user where id=#{id}
</delete>
而後在Test類中寫測試方法:
程序代碼
/**
* 刪除數據，刪除必定要 commit.
* @param id
*/
public void deleteUser(int id){
SqlSession session = sqlSessionFactory.openSession();
try {
IUserOperation userOperation=session.getMapper(IUserOperation.class);
userOperation.deleteUser(id);
session.commit();
} finally {
session.close();
}
}
這樣，全部增刪改查都完成了，注意在增長，更改，刪除的時候要調用session.commit()，這樣纔會真正對數據庫進行操做，不然是沒有提交的。
到此爲止，簡單的單表操做，應該都會了，接下來的時間了，我會講多表聯合查詢，以及結果集的選取。
除非申明,文章均爲
一號門原創,轉載請註明本文地址,謝謝!
有了前面幾章的基礎，對一些簡單的應用是能夠處理的，但在實際項目中，常常是關聯表的查詢，好比最多見到的多對一，一對多等。這些查詢是如何處理的呢，這一講就講這個問題。咱們首先建立一個Article 這個表，並初始化數據.
程序代碼
Drop TABLE IF EXISTS `article`;
Create TABLE `article` (
`id` int(11) NOT NULL auto_increment,
`userid` int(11) NOT NULL,
`title` varchar(100) NOT NULL,
`content` text NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;
-- ----------------------------
-- 添加幾條測試數據
-- ----------------------------
Insert INTO `article` VALUES ('1', '1', 'test_title', 'test_content');
Insert INTO `article` VALUES ('2', '1', 'test_title_2', 'test_content_2');
Insert INTO `article` VALUES ('3', '1', 'test_title_3', 'test_content_3');
Insert INTO `article` VALUES ('4', '1', 'test_title_4', 'test_content_4');
你應該發現了，這幾個文章對應的userid都是1，因此須要用戶表user裏面有id=1的數據。能夠修改爲知足本身條件的數據.按照orm的規則，表已經建立了，那麼確定須要一個對象與之對應，因此咱們增長一個 Article 的class
程序代碼
package com.yihaomen.mybatis.model;
public class Article {
private int id;
private User user;
private String title;
private String content;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
}
注意一下，文章的用戶是怎麼定義的，是直接定義的一個User對象。而不是int類型。
多對一的實現
場景:在讀取某個用戶發表的全部文章。固然仍是須要在User.xml 裏面配置 select 語句, 但重點是這個 select 的resultMap 對應什麼樣的數據呢。這是重點，這裏要引入 association 看定義以下:
程序代碼
<!-- User 聯合文章進行查詢 方法之一的配置 (多對一的方式) -->
<resultMap id="resultUserArticleList" type="Article">
<id property="id" column="aid" />
<result property="title" column="title" />
<result property="content" column="content" />
<association property="user" javaType="User">
<id property="id" column="id" />
<result property="userName" column="userName" />
<result property="userAddress" column="userAddress" />
</association>
</resultMap>
<select id="getUserArticles" parameterType="int" resultMap="resultUserArticleList">
select user.id,user.userName,user.userAddress,article.id aid,article.title,article.content from user,article
where user.id=article.userid and user.id=#{id}
</select>
這樣配置以後，就能夠了，將select 語句與resultMap 對應的映射結合起來看，就明白了。用association 來獲得關聯的用戶，這是多對一的狀況，由於全部的文章都是同一個用戶的。
還有另一種處理方式，能夠複用咱們前面已經定義好的 resultMap ,前面咱們定義過一個 resultListUser ,看這第二種方法如何實現:
程序代碼
<resultMap type="User" id="resultListUser">
<id column="id" property="id" />
<result column="userName" property="userName" />
<result column="userAge" property="userAge" />
<result column="userAddress" property="userAddress" />
</resultMap>
<!-- User 聯合文章進行查詢 方法之二的配置 (多對一的方式) -->
<resultMap id="resultUserArticleList-2" type="Article">
<id property="id" column="aid" />
<result property="title" column="title" />
<result property="content" column="content" />
<association property="user" javaType="User" resultMap="resultListUser" />
</resultMap>
<select id="getUserArticles" parameterType="int" resultMap="resultUserArticleList">
select user.id,user.userName,user.userAddress,article.id aid,article.title,article.content from user,article
where user.id=article.userid and user.id=#{id}
</select>
將 association 中對應的映射獨立抽取出來，能夠達到複用的目的。
好了，如今在Test 類中寫測試代碼:
程序代碼
public void getUserArticles(int userid){
SqlSession session = sqlSessionFactory.openSession();
try {
IUserOperation userOperation=session.getMapper(IUserOperation.class);
List<Article> articles = userOperation.getUserArticles(userid);
for(Article article:articles){
System.out.println(article.getTitle()+":"+article.getContent()+
":做者是:"+article.getUser().getUserName()+":地址:"+
article.getUser().getUserAddress());
}
} finally {
session.close();
}
}
漏掉了一點，咱們必定要在 IUserOperation 接口中，加入 select 對應的id 名稱相同的方法：
public List<Article> getUserArticles(int id);
而後運行就能夠測試。
整個程序下載：
點擊下載此文件
程序代碼
Drop TABLE IF EXISTS `article`;
Create TABLE `article` (
`id` int(11) NOT NULL auto_increment,
`userid` int(11) NOT NULL,
`title` varchar(100) NOT NULL,
`content` text NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;
-- ----------------------------
-- 添加幾條測試數據
-- ----------------------------
Insert INTO `article` VALUES ('1', '1', 'test_title', 'test_content');
Insert INTO `article` VALUES ('2', '1', 'test_title_2', 'test_content_2');
Insert INTO `article` VALUES ('3', '1', 'test_title_3', 'test_content_3');
Insert INTO `article` VALUES ('4', '1', 'test_title_4', 'test_content_4');
你應該發現了，這幾個文章對應的userid都是1，因此須要用戶表user裏面有id=1的數據。能夠修改爲知足本身條件的數據.按照orm的規則，表已經建立了，那麼確定須要一個對象與之對應，因此咱們增長一個 Article 的class
程序代碼
package com.yihaomen.mybatis.model;
public class Article {
private int id;
private User user;
private String title;
private String content;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
}
注意一下，文章的用戶是怎麼定義的，是直接定義的一個User對象。而不是int類型。
多對一的實現
場景:在讀取某個用戶發表的全部文章。固然仍是須要在User.xml 裏面配置 select 語句, 但重點是這個 select 的resultMap 對應什麼樣的數據呢。這是重點，這裏要引入 association 看定義以下:
程序代碼
<!-- User 聯合文章進行查詢 方法之一的配置 (多對一的方式) -->
<resultMap id="resultUserArticleList" type="Article">
<id property="id" column="aid" />
<result property="title" column="title" />
<result property="content" column="content" />
<association property="user" javaType="User">
<id property="id" column="id" />
<result property="userName" column="userName" />
<result property="userAddress" column="userAddress" />
</association>
</resultMap>
<select id="getUserArticles" parameterType="int" resultMap="resultUserArticleList">
select user.id,user.userName,user.userAddress,article.id aid,article.title,article.content from user,article
where user.id=article.userid and user.id=#{id}
</select>
這樣配置以後，就能夠了，將select 語句與resultMap 對應的映射結合起來看，就明白了。用association 來獲得關聯的用戶，這是多對一的狀況，由於全部的文章都是同一個用戶的。
還有另一種處理方式，能夠複用咱們前面已經定義好的 resultMap ,前面咱們定義過一個 resultListUser ,看這第二種方法如何實現:
程序代碼
<resultMap type="User" id="resultListUser">
<id column="id" property="id" />
<result column="userName" property="userName" />
<result column="userAge" property="userAge" />
<result column="userAddress" property="userAddress" />
</resultMap>
<!-- User 聯合文章進行查詢 方法之二的配置 (多對一的方式) -->
<resultMap id="resultUserArticleList-2" type="Article">
<id property="id" column="aid" />
<result property="title" column="title" />
<result property="content" column="content" />
<association property="user" javaType="User" resultMap="resultListUser" />
</resultMap>
<select id="getUserArticles" parameterType="int" resultMap="resultUserArticleList">
select user.id,user.userName,user.userAddress,article.id aid,article.title,article.content from user,article
where user.id=article.userid and user.id=#{id}
</select>
將 association 中對應的映射獨立抽取出來，能夠達到複用的目的。
好了，如今在Test 類中寫測試代碼:
程序代碼
public void getUserArticles(int userid){
SqlSession session = sqlSessionFactory.openSession();
try {
IUserOperation userOperation=session.getMapper(IUserOperation.class);
List<Article> articles = userOperation.getUserArticles(userid);
for(Article article:articles){
System.out.println(article.getTitle()+":"+article.getContent()+
":做者是:"+article.getUser().getUserName()+":地址:"+
article.getUser().getUserAddress());
}
} finally {
session.close();
}
}
漏掉了一點，咱們必定要在 IUserOperation 接口中，加入 select 對應的id 名稱相同的方法：
public List<Article> getUserArticles(int id);
而後運行就能夠測試。
整個程序下載：
點擊下載此文件
除非申明,文章均爲
一號門原創,轉載請註明本文地址,謝謝!
在這一系列文章中，前面講到純粹用mybatis 鏈接數據庫，而後 進行增刪改查，以及多表聯合查詢的的例子，但實際項目中，一般會用 spring 這個沾合劑來管理 datasource 等。充分利用spring 基於接口的編程，以及aop ,ioc 帶來的方便。用spring 來管理 mybatis 與管理hibernate 有不少相似的地方。今天的重點就是數據源管理以及 bean的配置。
你能夠下載源碼後，對比着看，源代碼沒有帶jar包，太大了，空間有限. 有截圖，你能夠看到用到哪些jar包，源碼在本文最後.
1. 首先對前面的工程結構作一點改變，在src_user源代碼目錄下創建文件夾config ,並將原來的 mybatis 配置文件 Configuration.xml 移動到這個文件夾中, 並在config 文家夾中創建 spring 配置文件：applicationContext.xml ，這個配置文件裏最主要的配置：
程序代碼
<!--本示例採用DBCP鏈接池，應預先把DBCP的jar包複製到工程的lib目錄下。 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?characterEncoding=utf8"/>
<property name="username" value="root"/>
<property name="password" value="password"/>
</bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!--dataSource屬性指定要用到的鏈接池-->
<property name="dataSource" ref="dataSource"/>
<!--configLocation屬性指定mybatis的核心配置文件-->
<property name="configLocation" value="config/Configuration.xml"/>
</bean>
<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
<!--sqlSessionFactory屬性指定要用到的SqlSessionFactory實例-->
<property name="sqlSessionFactory" ref="sqlSessionFactory" />
<!--mapperInterface屬性指定映射器接口，用於實現此接口並生成映射器對象-->
<property name="mapperInterface" value="com.yihaomen.mybatis.inter.IUserOperation" />
</bean>
[b]這裏面的重點就是 org.mybatis.spring.SqlSessionFactoryBean 與 org.mybatis.spring.mapper.MapperFactoryBean[b] 實現了 spring 的接口，併產生對象。詳細能夠查看 mybatis-spring 代碼。（ http://code.google.com/p/mybatis/）,若是僅僅使用，固定模式，這樣配置就好。
而後寫測試程序
程序代碼
package com.yihaomen.test;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.yihaomen.mybatis.inter.IUserOperation;
import com.yihaomen.mybatis.model.Article;
import com.yihaomen.mybatis.model.User;
public class MybatisSprintTest {
private static ApplicationContext ctx;
static
{
ctx = new ClassPathXmlApplicationContext("config/applicationContext.xml");
}
public static void main(String[] args)
{
IUserOperation mapper = (IUserOperation)ctx.getBean("userMapper");
//測試id=1的用戶查詢，根據數據庫中的狀況，能夠改爲你本身的.
System.out.println("獲得用戶id=1的用戶信息");
User user = mapper.selectUserByID(1);
System.out.println(user.getUserAddress());
//獲得文章列表測試
System.out.println("獲得用戶id爲1的全部文章列表");
List<Article> articles = mapper.getUserArticles(1);
for(Article article:articles){
System.out.println(article.getContent()+"--"+article.getTitle());
}
}
}
運行便可獲得相應的結果.
工程圖：
用到的jar包，以下圖：
源代碼下載，不帶 jar 包，
點擊下載此文件
你能夠下載源碼後，對比着看，源代碼沒有帶jar包，太大了，空間有限. 有截圖，你能夠看到用到哪些jar包，源碼在本文最後.
1. 首先對前面的工程結構作一點改變，在src_user源代碼目錄下創建文件夾config ,並將原來的 mybatis 配置文件 Configuration.xml 移動到這個文件夾中, 並在config 文家夾中創建 spring 配置文件：applicationContext.xml ，這個配置文件裏最主要的配置：
程序代碼
<!--本示例採用DBCP鏈接池，應預先把DBCP的jar包複製到工程的lib目錄下。 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?characterEncoding=utf8"/>
<property name="username" value="root"/>
<property name="password" value="password"/>
</bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!--dataSource屬性指定要用到的鏈接池-->
<property name="dataSource" ref="dataSource"/>
<!--configLocation屬性指定mybatis的核心配置文件-->
<property name="configLocation" value="config/Configuration.xml"/>
</bean>
<bean id="userMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
<!--sqlSessionFactory屬性指定要用到的SqlSessionFactory實例-->
<property name="sqlSessionFactory" ref="sqlSessionFactory" />
<!--mapperInterface屬性指定映射器接口，用於實現此接口並生成映射器對象-->
<property name="mapperInterface" value="com.yihaomen.mybatis.inter.IUserOperation" />
</bean>
[b]這裏面的重點就是 org.mybatis.spring.SqlSessionFactoryBean 與 org.mybatis.spring.mapper.MapperFactoryBean[b] 實現了 spring 的接口，併產生對象。詳細能夠查看 mybatis-spring 代碼。（ http://code.google.com/p/mybatis/）,若是僅僅使用，固定模式，這樣配置就好。
而後寫測試程序
程序代碼
package com.yihaomen.test;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.yihaomen.mybatis.inter.IUserOperation;
import com.yihaomen.mybatis.model.Article;
import com.yihaomen.mybatis.model.User;
public class MybatisSprintTest {
private static ApplicationContext ctx;
static
{
ctx = new ClassPathXmlApplicationContext("config/applicationContext.xml");
}
public static void main(String[] args)
{
IUserOperation mapper = (IUserOperation)ctx.getBean("userMapper");
//測試id=1的用戶查詢，根據數據庫中的狀況，能夠改爲你本身的.
System.out.println("獲得用戶id=1的用戶信息");
User user = mapper.selectUserByID(1);
System.out.println(user.getUserAddress());
//獲得文章列表測試
System.out.println("獲得用戶id爲1的全部文章列表");
List<Article> articles = mapper.getUserArticles(1);
for(Article article:articles){
System.out.println(article.getContent()+"--"+article.getTitle());
}
}
}
運行便可獲得相應的結果.
工程圖：
用到的jar包，以下圖：
源代碼下載，不帶 jar 包，
點擊下載此文件
除非申明,文章均爲
一號門原創,轉載請註明本文地址,謝謝!
前面幾篇文章已經講到了mybatis與spring 的集成。但這個時候，全部的工程還不是web工程，雖然我一直是建立的web 工程。今天將直接用mybatis與Spring mvc 的方式集成起來，源碼在本文結尾處下載.主要有如下幾個方面的配置
1. web.xml 配置 spring dispatchservlet ,好比爲:mvc-dispatcher
2. mvc-dispatcher-servlet.xml 文件配置
3. spring applicationContext.XML文件配置(與數據庫相關，與mybatis sqlSessionFaction 整合，掃描全部mybatis mapper 文件等.)
4. 編寫controller 類
5. 編寫頁面代碼.
先有個大概映像，整個工程圖以下:
[/code]
1. web.xml 配置 spring dispatchservlet ,好比爲:mvc-dispatcher
程序代碼
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:config/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<listener>
<listener-class>
org.springframework.web.context.ContextCleanupListener</listener-class>
</listener>
<servlet>
<servlet-name>mvc-dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>mvc-dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
2. 在web.xml 同目錄下配置 mvc-dispatcher-servlet.xml 文件,這個文件名前面部分必須與你在web.xml裏面配置的DispatcherServlet 的servlet名字對應.其內容爲:
程序代碼
<beans xmlns=" http://www.springframework.org/schema/beans"
xmlns:context=" http://www.springframework.org/schema/context"
xmlns:mvc=" http://www.springframework.org/schema/mvc" xmlns:xsi=" http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
<context:component-scan base-package="com.yihaomen.controller" />
<mvc:annotation-driven />
<mvc:resources mapping="/static/**" location="/WEB-INF/static/"/>
<mvc:default-servlet-handler/>
<bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix">
<value>/WEB-INF/pages/</value>
</property>
<property name="suffix">
<value>.jsp</value>
</property>
</bean>
</beans>
3. 在源碼目錄 config 目錄下配置 spring 配置文件 applicationContext.xml
程序代碼
<!--本示例採用DBCP鏈接池，應預先把DBCP的jar包複製到工程的lib目錄下。 -->
<context:property-placeholder location="classpath:/config/database.properties" />
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close" p:driverClassName="com.mysql.jdbc.Driver"
p:url="jdbc:mysql://127.0.0.1:3306/mybatis?characterEncoding=utf8"
p:username="root" p:password="password"
p:maxActive="10" p:maxIdle="10">
</bean>
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!--dataSource屬性指定要用到的鏈接池-->
<property name="dataSource" ref="dataSource"/>
<!--configLocation屬性指定mybatis的核心配置文件-->
<property name="configLocation" value="classpath:config/Configuration.xml" />
<!-- 全部配置的mapper文件 -->
<property name="mapperLocations" value="classpath*:com/yihaomen/mapper/*.xml" />
</bean>
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.yihaomen.inter" />
</bean>
不知道爲何，一旦我用了 MapperScannerConfigurer 去掃描全部的mapper 接口時，數據庫配置datasource 就不能用讀取database.properties文件了。報錯： Cannot load JDBC driver class '${jdbc.driverClassName}'，網上有人說在spring 3.1.1 下用 sqlSessionFactionBean 注入能夠解決，但我用 spring 3.1.3 仍是有問題，因此只好把數據庫鏈接信息直接配置在了XML 文件裏面。
4. 編寫 controller 層
程序代碼
package com.yihaomen.controller;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import com.yihaomen.inter.IUserOperation;
import com.yihaomen.model.Article;
@Controller
@RequestMapping("/article")
public class UserController {
@Autowired
IUserOperation userMapper;
@RequestMapping("/list")
public ModelAndView listall(HttpServletRequest request,HttpServletResponse response){
List<Article> articles=userMapper.getUserArticles(1);
ModelAndView mav=new ModelAndView("list");
mav.addObject("articles",articles);
return mav;
}
}
5. 頁面文件:
[code]
<c:forEach items="${articles}" var="item">
${item.id }--${item.title }--${item.content }<br />
</c:forEach>
運行結果：
固然還有 mybatis 的Configure.xml 配置文件，與上一講的差很少，惟一不一樣的就是不用再配置相似以下的： <mapper resource="com/yihaomen/mapper/User.xml"/> ，全部這些都交給 在配置 sqlSessionFactory 的時候，由 <property name="mapperLocations" value="classpath*:com/yihaomen/mapper/*.xml" /> 去導入了。
源碼下載：
mybatis spring3 MVC 程序下載
數據庫下載：
spring mvc 數據庫測試文件
1. web.xml 配置 spring dispatchservlet ,好比爲:mvc-dispatcher
2. mvc-dispatcher-servlet.xml 文件配置
3. spring applicationContext.XML文件配置(與數據庫相關，與mybatis sqlSessionFaction 整合，掃描全部mybatis mapper 文件等.)
4. 編寫controller 類
5. 編寫頁面代碼.
先有個大概映像，整個工程圖以下:
[/code]
1. web.xml 配置 spring dispatchservlet ,好比爲:mvc-dispatcher
程序代碼
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:config/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<listener>
<listener-class>
org.springframework.web.context.ContextCleanupListener</listener-class>
</listener>
<servlet>
<servlet-name>mvc-dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>mvc-dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
2. 在web.xml 同目錄下配置 mvc-dispatcher-servlet.xml 文件,這個文件名前面部分必須與你在web.xml裏面配置的DispatcherServlet 的servlet名字對應.其內容爲:
程序代碼
<beans xmlns=" http://www.springframework.org/schema/beans"
xmlns:context=" http://www.springframework.org/schema/context"
xmlns:mvc=" http://www.springframework.org/schema/mvc" xmlns:xsi=" http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
<context:component-scan base-package="com.yihaomen.controller" />
<mvc:annotation-driven />
<mvc:resources mapping="/static/**" location="/WEB-INF/static/"/>
<mvc:default-servlet-handler/>
<bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix">
<value>/WEB-INF/pages/</value>
</property>
<property name="suffix">
<value>.jsp</value>
</property>
</bean>
</beans>
3. 在源碼目錄 config 目錄下配置 spring 配置文件 applicationContext.xml
程序代碼
<!--本示例採用DBCP鏈接池，應預先把DBCP的jar包複製到工程的lib目錄下。 -->
<context:property-placeholder location="classpath:/config/database.properties" />
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close" p:driverClassName="com.mysql.jdbc.Driver"
p:url="jdbc:mysql://127.0.0.1:3306/mybatis?characterEncoding=utf8"
p:username="root" p:password="password"
p:maxActive="10" p:maxIdle="10">
</bean>
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<!--dataSource屬性指定要用到的鏈接池-->
<property name="dataSource" ref="dataSource"/>
<!--configLocation屬性指定mybatis的核心配置文件-->
<property name="configLocation" value="classpath:config/Configuration.xml" />
<!-- 全部配置的mapper文件 -->
<property name="mapperLocations" value="classpath*:com/yihaomen/mapper/*.xml" />
</bean>
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.yihaomen.inter" />
</bean>
不知道爲何，一旦我用了 MapperScannerConfigurer 去掃描全部的mapper 接口時，數據庫配置datasource 就不能用讀取database.properties文件了。報錯： Cannot load JDBC driver class '${jdbc.driverClassName}'，網上有人說在spring 3.1.1 下用 sqlSessionFactionBean 注入能夠解決，但我用 spring 3.1.3 仍是有問題，因此只好把數據庫鏈接信息直接配置在了XML 文件裏面。
4. 編寫 controller 層
程序代碼
package com.yihaomen.controller;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
import com.yihaomen.inter.IUserOperation;
import com.yihaomen.model.Article;
@Controller
@RequestMapping("/article")
public class UserController {
@Autowired
IUserOperation userMapper;
@RequestMapping("/list")
public ModelAndView listall(HttpServletRequest request,HttpServletResponse response){
List<Article> articles=userMapper.getUserArticles(1);
ModelAndView mav=new ModelAndView("list");
mav.addObject("articles",articles);
return mav;
}
}
5. 頁面文件:
[code]
<c:forEach items="${articles}" var="item">
${item.id }--${item.title }--${item.content }<br />
</c:forEach>
運行結果：
固然還有 mybatis 的Configure.xml 配置文件，與上一講的差很少，惟一不一樣的就是不用再配置相似以下的： <mapper resource="com/yihaomen/mapper/User.xml"/> ，全部這些都交給 在配置 sqlSessionFactory 的時候，由 <property name="mapperLocations" value="classpath*:com/yihaomen/mapper/*.xml" /> 去導入了。
源碼下載：
mybatis spring3 MVC 程序下載
數據庫下載：
spring mvc 數據庫測試文件
除非申明,文章均爲
一號門原創,轉載請註明本文地址,謝謝!
上一篇文章裏已經講到了mybatis與spring MVC的集成，而且作了一個列表展現，顯示出全部article 列表，但沒有用到分頁，在實際的項目中，分頁是確定須要的。並且是物理分頁，不是內存分頁。對於物理分頁方案，不一樣的數據庫，有不一樣的實現方法,對於mysql 來講 就是利用 limit offset,pagesize 方式來實現的。oracle 是經過rownum 來實現的，若是你熟悉相關數據庫的操做，是同樣的很好擴展，本文以mysql 爲例子來說述.先看一下效果圖(源代碼在文章最後提供下載):
實現mybatis 物理分頁，一個最簡單的方式是，是在你的mapper的SQL語句中直接寫相似以下方式 :
程序代碼
<select id="getUserArticles" parameterType="Your_params" resultMap="resultUserArticleList">
select user.id,user.userName,user.userAddress,article.id aid,article.title,article.content from user,article
where user.id=article.userid and user.id=#{id} limit #{offset},#{pagesize}
</select>
請注意這裏的 parameterType 是你傳入的參數類，或者map ，裏面包含了offset,pagesize ,和其餘你須要的參數，用這種方式，確定能夠實現分頁。這是簡單的一種方式。但更通用的一種方式是用 mybatis 插件的方式. 參考了網上的不少資料 ，mybatis plugin 方面的資料。寫本身的插件.
程序代碼
package com.yihaomen.util;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import javax.xml.bind.PropertyException;
import org.apache.ibatis.builder.xml.dynamic.ForEachSqlNode;
import org.apache.ibatis.executor.ErrorContext;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.executor.ExecutorException;
import org.apache.ibatis.executor.statement.BaseStatementHandler;
import org.apache.ibatis.executor.statement.RoutingStatementHandler;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.mapping.ParameterMode;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.property.PropertyTokenizer;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.type.TypeHandler;
import org.apache.ibatis.type.TypeHandlerRegistry;
@Intercepts({ @Signature(type = StatementHandler.class, method = "prepare", args = { Connection.class }) })
public class PagePlugin implements Interceptor {
private static String dialect = "";
private static String pageSqlId = "";
@SuppressWarnings("unchecked")
public Object intercept(Invocation ivk) throws Throwable {
if (ivk.getTarget() instanceof RoutingStatementHandler) {
RoutingStatementHandler statementHandler = (RoutingStatementHandler) ivk
.getTarget();
BaseStatementHandler delegate = (BaseStatementHandler) ReflectHelper
.getValueByFieldName(statementHandler, "delegate");
MappedStatement mappedStatement = (MappedStatement) ReflectHelper
.getValueByFieldName(delegate, "mappedStatement");
if (mappedStatement.getId().matches(pageSqlId)) {
BoundSql boundSql = delegate.getBoundSql();
Object parameterObject = boundSql.getParameterObject();
if (parameterObject == null) {
throw new NullPointerException("parameterObject error");
} else {
Connection connection = (Connection) ivk.getArgs()[0];
String sql = boundSql.getSql();
String countSql = "select count(0) from (" + sql + ") myCount";
System.out.println("總數sql 語句:"+countSql);
PreparedStatement countStmt = connection
.prepareStatement(countSql);
BoundSql countBS = new BoundSql(
mappedStatement.getConfiguration(), countSql,
boundSql.getParameterMappings(), parameterObject);
setParameters(countStmt, mappedStatement, countBS,
parameterObject);
ResultSet rs = countStmt.executeQuery();
int count = 0;
if (rs.next()) {
count = rs.getInt(1);
}
rs.close();
countStmt.close();
PageInfo page = null;
if (parameterObject instanceof PageInfo) {
page = (PageInfo) parameterObject;
page.setTotalResult(count);
} else if(parameterObject instanceof Map){
Map<String, Object> map = (Map<String, Object>)parameterObject;
page = (PageInfo)map.get("page");
if(page == null)
page = new PageInfo();
page.setTotalResult(count);
}else {
Field pageField = ReflectHelper.getFieldByFieldName(
parameterObject, "page");
if (pageField != null) {
page = (PageInfo) ReflectHelper.getValueByFieldName(
parameterObject, "page");
if (page == null)
page = new PageInfo();
page.setTotalResult(count);
ReflectHelper.setValueByFieldName(parameterObject,
"page", page);
} else {
throw new NoSuchFieldException(parameterObject
.getClass().getName());
}
}
String pageSql = generatePageSql(sql, page);
System.out.println("page sql:"+pageSql);
ReflectHelper.setValueByFieldName(boundSql, "sql", pageSql);
}
}
}
return ivk.proceed();
}
private void setParameters(PreparedStatement ps,
MappedStatement mappedStatement, BoundSql boundSql,
Object parameterObject) throws SQLException {
ErrorContext.instance().activity("setting parameters")
.object(mappedStatement.getParameterMap().getId());
List<ParameterMapping> parameterMappings = boundSql
.getParameterMappings();
if (parameterMappings != null) {
Configuration configuration = mappedStatement.getConfiguration();
TypeHandlerRegistry typeHandlerRegistry = configuration
.getTypeHandlerRegistry();
MetaObject metaObject = parameterObject == null ? null
: configuration.newMetaObject(parameterObject);
for (int i = 0; i < parameterMappings.size(); i++) {
ParameterMapping parameterMapping = parameterMappings.get(i);
if (parameterMapping.getMode() != ParameterMode.OUT) {
Object value;
String propertyName = parameterMapping.getProperty();
PropertyTokenizer prop = new PropertyTokenizer(propertyName);
if (parameterObject == null) {
value = null;
} else if (typeHandlerRegistry
.hasTypeHandler(parameterObject.getClass())) {
value = parameterObject;
} else if (boundSql.hasAdditionalParameter(propertyName)) {
value = boundSql.getAdditionalParameter(propertyName);
} else if (propertyName
.startsWith(ForEachSqlNode.ITEM_PREFIX)
&& boundSql.hasAdditionalParameter(prop.getName())) {
value = boundSql.getAdditionalParameter(prop.getName());
if (value != null) {
value = configuration.newMetaObject(value)
.getValue(
propertyName.substring(prop
.getName().length()));
}
} else {
value = metaObject == null ? null : metaObject
.getValue(propertyName);
}
TypeHandler typeHandler = parameterMapping.getTypeHandler();
if (typeHandler == null) {
throw new ExecutorException(
"There was no TypeHandler found for parameter "
+ propertyName + " of statement "
+ mappedStatement.getId());
}
typeHandler.setParameter(ps, i + 1, value,
parameterMapping.getJdbcType());
}
}
}
}
private String generatePageSql(String sql, PageInfo page) {
if (page != null && (dialect !=null || !dialect.equals(""))) {
StringBuffer pageSql = new StringBuffer();
if ("mysql".equals(dialect)) {
pageSql.append(sql);
pageSql.append(" limit " + page.getCurrentResult() + ","
+ page.getShowCount());
} else if ("oracle".equals(dialect)) {
pageSql.append("select * from (select tmp_tb.*,ROWNUM row_id from (");
pageSql.append(sql);
pageSql.append(") tmp_tb where ROWNUM<=");
pageSql.append(page.getCurrentResult() + page.getShowCount());
pageSql.append(") where row_id>");
pageSql.append(page.getCurrentResult());
}
return pageSql.toString();
} else {
return sql;
}
}
public Object plugin(Object arg0) {
// TODO Auto-generated method stub
return Plugin.wrap(arg0, this);
}
public void setProperties(Properties p) {
dialect = p.getProperty("dialect");
if (dialect ==null || dialect.equals("")) {
try {
throw new PropertyException("dialect property is not found!");
} catch (PropertyException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
pageSqlId = p.getProperty("pageSqlId");
if (dialect ==null || dialect.equals("")) {
try {
throw new PropertyException("pageSqlId property is not found!");
} catch (PropertyException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
此插件有兩個輔助類:PageInfo,ReflectHelper,你能夠下載源代碼參考。
寫了插件以後，固然須要在 mybatis 的配置文件Configuration.xml 裏配置這個插件
程序代碼
<plugins>
<plugin interceptor="com.yihaomen.util.PagePlugin">
<property name="dialect" value="mysql" />
<property name="pageSqlId" value=".*ListPage.*" />
</plugin>
</plugins>
請注意，這個插件定義了一個規則，也就是在mapper中sql語句的id 必須包含ListPage才能被攔截。不然將不會分頁處理.
插件寫好了，如今就能夠在 spring mvc 中的controller 層中寫一個方法來測試這個分頁:
程序代碼
@RequestMapping("/pagelist")
public ModelAndView pageList(HttpServletRequest request,HttpServletResponse response){
int currentPage = request.getParameter("page")==null?1:Integer.parseInt(request.getParameter("page"));
int pageSize = 3;
if (currentPage<=0){
currentPage =1;
}
int currentResult = (currentPage-1) * pageSize;
System.out.println(request.getRequestURI());
System.out.println(request.getQueryString());
PageInfo page = new PageInfo();
page.setShowCount(pageSize);
page.setCurrentResult(currentResult);
List<Article> articles=iUserOperation.selectArticleListPage(page,1);
System.out.println(page);
int totalCount = page.getTotalResult();
int lastPage=0;
if (totalCount % pageSize==0){
lastPage = totalCount % pageSize;
}
else{
lastPage =1+ totalCount / pageSize;
}
if (currentPage>=lastPage){
currentPage =lastPage;
}
String pageStr = "";
pageStr=String.format("<a href=\"%s\">上一頁</a> <a href=\"%s\">下一頁</a>",
request.getRequestURI()+"?page="+(currentPage-1),request.getRequestURI()+"?page="+(currentPage+1) );
//制定視圖，也就是list.jsp
ModelAndView mav=new ModelAndView("list");
mav.addObject("articles",articles);
mav.addObject("pageStr",pageStr);
return mav;
}
而後運行程序，進入分頁頁面，你就能夠看到結果了:
源代碼下載:
點擊下載此文件
相關jar 包下載，請到下載這裏例子中的jar
http://www.yihaomen.com/article/java/318.htm (文章最後有源代碼下載，裏面有jar 包,拷貝到上面源代碼裏面所須要的lib 目錄下.)
另外，你還得在前面提到的數據庫artilce表裏面，多插入一些記錄，分頁效果就更好。
實現mybatis 物理分頁，一個最簡單的方式是，是在你的mapper的SQL語句中直接寫相似以下方式 :
程序代碼
<select id="getUserArticles" parameterType="Your_params" resultMap="resultUserArticleList">
select user.id,user.userName,user.userAddress,article.id aid,article.title,article.content from user,article
where user.id=article.userid and user.id=#{id} limit #{offset},#{pagesize}
</select>
請注意這裏的 parameterType 是你傳入的參數類，或者map ，裏面包含了offset,pagesize ,和其餘你須要的參數，用這種方式，確定能夠實現分頁。這是簡單的一種方式。但更通用的一種方式是用 mybatis 插件的方式. 參考了網上的不少資料 ，mybatis plugin 方面的資料。寫本身的插件.
程序代碼
package com.yihaomen.util;
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import javax.xml.bind.PropertyException;
import org.apache.ibatis.builder.xml.dynamic.ForEachSqlNode;
import org.apache.ibatis.executor.ErrorContext;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.executor.ExecutorException;
import org.apache.ibatis.executor.statement.BaseStatementHandler;
import org.apache.ibatis.executor.statement.RoutingStatementHandler;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.mapping.ParameterMode;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.property.PropertyTokenizer;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.type.TypeHandler;
import org.apache.ibatis.type.TypeHandlerRegistry;
@Intercepts({ @Signature(type = StatementHandler.class, method = "prepare", args = { Connection.class }) })
public class PagePlugin implements Interceptor {
private static String dialect = "";
private static String pageSqlId = "";
@SuppressWarnings("unchecked")
public Object intercept(Invocation ivk) throws Throwable {
if (ivk.getTarget() instanceof RoutingStatementHandler) {
RoutingStatementHandler statementHandler = (RoutingStatementHandler) ivk
.getTarget();
BaseStatementHandler delegate = (BaseStatementHandler) ReflectHelper
.getValueByFieldName(statementHandler, "delegate");
MappedStatement mappedStatement = (MappedStatement) ReflectHelper
.getValueByFieldName(delegate, "mappedStatement");
if (mappedStatement.getId().matches(pageSqlId)) {
BoundSql boundSql = delegate.getBoundSql();
Object parameterObject = boundSql.getParameterObject();
if (parameterObject == null) {
throw new NullPointerException("parameterObject error");
} else {
Connection connection = (Connection) ivk.getArgs()[0];
String sql = boundSql.getSql();
String countSql = "select count(0) from (" + sql + ") myCount";
System.out.println("總數sql 語句:"+countSql);
PreparedStatement countStmt = connection
.prepareStatement(countSql);
BoundSql countBS = new BoundSql(
mappedStatement.getConfiguration(), countSql,
boundSql.getParameterMappings(), parameterObject);
setParameters(countStmt, mappedStatement, countBS,
parameterObject);
ResultSet rs = countStmt.executeQuery();
int count = 0;
if (rs.next()) {
count = rs.getInt(1);
}
rs.close();
countStmt.close();
PageInfo page = null;
if (parameterObject instanceof PageInfo) {
page = (PageInfo) parameterObject;
page.setTotalResult(count);
} else if(parameterObject instanceof Map){
Map<String, Object> map = (Map<String, Object>)parameterObject;
page = (PageInfo)map.get("page");
if(page == null)
page = new PageInfo();
page.setTotalResult(count);
}else {
Field pageField = ReflectHelper.getFieldByFieldName(
parameterObject, "page");
if (pageField != null) {
page = (PageInfo) ReflectHelper.getValueByFieldName(
parameterObject, "page");
if (page == null)
page = new PageInfo();
page.setTotalResult(count);
ReflectHelper.setValueByFieldName(parameterObject,
"page", page);
} else {
throw new NoSuchFieldException(parameterObject
.getClass().getName());
}
}
String pageSql = generatePageSql(sql, page);
System.out.println("page sql:"+pageSql);
ReflectHelper.setValueByFieldName(boundSql, "sql", pageSql);
}
}
}
return ivk.proceed();
}
private void setParameters(PreparedStatement ps,
MappedStatement mappedStatement, BoundSql boundSql,
Object parameterObject) throws SQLException {
ErrorContext.instance().activity("setting parameters")
.object(mappedStatement.getParameterMap().getId());
List<ParameterMapping> parameterMappings = boundSql
.getParameterMappings();
if (parameterMappings != null) {
Configuration configuration = mappedStatement.getConfiguration();
TypeHandlerRegistry typeHandlerRegistry = configuration
.getTypeHandlerRegistry();
MetaObject metaObject = parameterObject == null ? null
: configuration.newMetaObject(parameterObject);
for (int i = 0; i < parameterMappings.size(); i++) {
ParameterMapping parameterMapping = parameterMappings.get(i);
if (parameterMapping.getMode() != ParameterMode.OUT) {
Object value;
String propertyName = parameterMapping.getProperty();
PropertyTokenizer prop = new PropertyTokenizer(propertyName);
if (parameterObject == null) {
value = null;
} else if (typeHandlerRegistry
.hasTypeHandler(parameterObject.getClass())) {
value = parameterObject;
} else if (boundSql.hasAdditionalParameter(propertyName)) {
value = boundSql.getAdditionalParameter(propertyName);
} else if (propertyName
.startsWith(ForEachSqlNode.ITEM_PREFIX)
&& boundSql.hasAdditionalParameter(prop.getName())) {
value = boundSql.getAdditionalParameter(prop.getName());
if (value != null) {
value = configuration.newMetaObject(value)
.getValue(
propertyName.substring(prop
.getName().length()));
}
} else {
value = metaObject == null ? null : metaObject
.getValue(propertyName);
}
TypeHandler typeHandler = parameterMapping.getTypeHandler();
if (typeHandler == null) {
throw new ExecutorException(
"There was no TypeHandler found for parameter "
+ propertyName + " of statement "
+ mappedStatement.getId());
}
typeHandler.setParameter(ps, i + 1, value,
parameterMapping.getJdbcType());
}
}
}
}
private String generatePageSql(String sql, PageInfo page) {
if (page != null && (dialect !=null || !dialect.equals(""))) {
StringBuffer pageSql = new StringBuffer();
if ("mysql".equals(dialect)) {
pageSql.append(sql);
pageSql.append(" limit " + page.getCurrentResult() + ","
+ page.getShowCount());
} else if ("oracle".equals(dialect)) {
pageSql.append("select * from (select tmp_tb.*,ROWNUM row_id from (");
pageSql.append(sql);
pageSql.append(") tmp_tb where ROWNUM<=");
pageSql.append(page.getCurrentResult() + page.getShowCount());
pageSql.append(") where row_id>");
pageSql.append(page.getCurrentResult());
}
return pageSql.toString();
} else {
return sql;
}
}
public Object plugin(Object arg0) {
// TODO Auto-generated method stub
return Plugin.wrap(arg0, this);
}
public void setProperties(Properties p) {
dialect = p.getProperty("dialect");
if (dialect ==null || dialect.equals("")) {
try {
throw new PropertyException("dialect property is not found!");
} catch (PropertyException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
pageSqlId = p.getProperty("pageSqlId");
if (dialect ==null || dialect.equals("")) {
try {
throw new PropertyException("pageSqlId property is not found!");
} catch (PropertyException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
此插件有兩個輔助類:PageInfo,ReflectHelper,你能夠下載源代碼參考。
寫了插件以後，固然須要在 mybatis 的配置文件Configuration.xml 裏配置這個插件
程序代碼
<plugins>
<plugin interceptor="com.yihaomen.util.PagePlugin">
<property name="dialect" value="mysql" />
<property name="pageSqlId" value=".*ListPage.*" />
</plugin>
</plugins>
請注意，這個插件定義了一個規則，也就是在mapper中sql語句的id 必須包含ListPage才能被攔截。不然將不會分頁處理.
插件寫好了，如今就能夠在 spring mvc 中的controller 層中寫一個方法來測試這個分頁:
程序代碼
@RequestMapping("/pagelist")
public ModelAndView pageList(HttpServletRequest request,HttpServletResponse response){
int currentPage = request.getParameter("page")==null?1:Integer.parseInt(request.getParameter("page"));
int pageSize = 3;
if (currentPage<=0){
currentPage =1;
}
int currentResult = (currentPage-1) * pageSize;
System.out.println(request.getRequestURI());
System.out.println(request.getQueryString());
PageInfo page = new PageInfo();
page.setShowCount(pageSize);
page.setCurrentResult(currentResult);
List<Article> articles=iUserOperation.selectArticleListPage(page,1);
System.out.println(page);
int totalCount = page.getTotalResult();
int lastPage=0;
if (totalCount % pageSize==0){
lastPage = totalCount % pageSize;
}
else{
lastPage =1+ totalCount / pageSize;
}
if (currentPage>=lastPage){
currentPage =lastPage;
}
String pageStr = "";
pageStr=String.format("<a href=\"%s\">上一頁</a> <a href=\"%s\">下一頁</a>",
request.getRequestURI()+"?page="+(currentPage-1),request.getRequestURI()+"?page="+(currentPage+1) );
//制定視圖，也就是list.jsp
ModelAndView mav=new ModelAndView("list");
mav.addObject("articles",articles);
mav.addObject("pageStr",pageStr);
return mav;
}
而後運行程序，進入分頁頁面，你就能夠看到結果了:
源代碼下載:
點擊下載此文件
相關jar 包下載，請到下載這裏例子中的jar
http://www.yihaomen.com/article/java/318.htm (文章最後有源代碼下載，裏面有jar 包,拷貝到上面源代碼裏面所須要的lib 目錄下.)
另外，你還得在前面提到的數據庫artilce表裏面，多插入一些記錄，分頁效果就更好。
除非申明,文章均爲
一號門原創,轉載請註明本文地址,謝謝!
mybatis 的動態sql語句是基於OGNL表達式的。能夠方便的在 sql 語句中實現某些邏輯. 整體說來mybatis 動態SQL 語句主要有如下幾類:
1. if 語句 (簡單的條件判斷)
2. choose (when,otherwize) ,至關於java 語言中的 switch ,與 jstl 中的choose 很相似.
3. trim (對包含的內容加上 prefix,或者 suffix 等，前綴，後綴)
4. where (主要是用來簡化sql語句中where條件判斷的，能智能的處理 and or ,沒必要擔憂多餘致使語法錯誤)
5. set (主要用於更新時)
6. foreach (在實現 mybatis in 語句查詢時特別有用)
下面分別介紹這幾種處理方式
1. mybaits if 語句處理
程序代碼
<select id="dynamicIfTest" parameterType="Blog" resultType="Blog">
select * from t_blog where 1 = 1
<if test="title != null">
and title = #{title}
</if>
<if test="content != null">
and content = #{content}
</if>
<if test="owner != null">
and owner = #{owner}
</if>
</select>
這條語句的意思很是簡單，若是你提供了title參數，那麼就要知足title=#{title}，一樣若是你提供了Content和Owner的時候，它們也須要知足相應的條件，以後就是返回知足這些條件的全部Blog，這是很是有用的一個功能，以往咱們使用其餘類型框架或者直接使用JDBC的時候， 若是咱們要達到一樣的選擇效果的時候，咱們就須要拼SQL語句，這是極其麻煩的，比起來，上述的動態SQL就要簡單多了
2.2. choose (when,otherwize) ,至關於java 語言中的 switch ,與 jstl 中的choose 很相似
程序代碼
<select id="dynamicChooseTest" parameterType="Blog" resultType="Blog">
select * from t_blog where 1 = 1
<choose>
<when test="title != null">
and title = #{title}
</when>
<when test="content != null">
and content = #{content}
</when>
<otherwise>
and owner = "owner1"
</otherwise>
</choose>
</select>
when元素表示當when中的條件知足的時候就輸出其中的內容，跟JAVA中的switch效果差很少的是按照條件的順序，當when中有條件知足的時候，就會跳出choose，即全部的when和otherwise條件中，只有一個會輸出，當全部的我很條件都不知足的時候就輸出otherwise中的內容。因此上述語句的意思很是簡單， 當title!=null的時候就輸出and titlte = #{title}，再也不往下判斷條件，當title爲空且content!=null的時候就輸出and content = #{content}，當全部條件都不知足的時候就輸出otherwise中的內容。
3.trim (對包含的內容加上 prefix,或者 suffix 等，前綴，後綴)
程序代碼
<select id="dynamicTrimTest" parameterType="Blog" resultType="Blog">
select * from t_blog
<trim prefix="where" prefixOverrides="and |or">
<if test="title != null">
title = #{title}
</if>
<if test="content != null">
and content = #{content}
</if>
<if test="owner != null">
or owner = #{owner}
</if>
</trim>
</select>
trim元素的主要功能是能夠在本身包含的內容前加上某些前綴，也能夠在其後加上某些後綴，與之對應的屬性是prefix和suffix；能夠把包含內容的首部某些內容覆蓋，即忽略，也能夠把尾部的某些內容覆蓋，對應的屬性是prefixOverrides和suffixOverrides；正由於trim有這樣的功能，因此咱們也能夠很是簡單的利用trim來代替where元素的功能
4. where (主要是用來簡化sql語句中where條件判斷的，能智能的處理 and or 條件
程序代碼
<select id="dynamicWhereTest" parameterType="Blog" resultType="Blog">
select * from t_blog
<where>
<if test="title != null">
title = #{title}
</if>
<if test="content != null">
and content = #{content}
</if>
<if test="owner != null">
and owner = #{owner}
</if>
</where>
</select>
where元素的做用是會在寫入where元素的地方輸出一個where，另一個好處是你不須要考慮where元素裏面的條件輸出是什麼樣子的，MyBatis會智能的幫你處理，若是全部的條件都不知足那麼MyBatis就會查出全部的記錄，若是輸出後是and 開頭的，MyBatis會把第一個and忽略，固然若是是or開頭的，MyBatis也會把它忽略；此外，在where元素中你不須要考慮空格的問題，MyBatis會智能的幫你加上。像上述例子中，若是title=null， 而content != null，那麼輸出的整個語句會是select * from t_blog where content = #{content}，而不是select * from t_blog where and content = #{content}，由於MyBatis會智能的把首個and 或 or 給忽略。
5.set (主要用於更新時)
程序代碼
<update id="dynamicSetTest" parameterType="Blog">
update t_blog
<set>
<if test="title != null">
title = #{title},
</if>
<if test="content != null">
content = #{content},
</if>
<if test="owner != null">
owner = #{owner}
</if>
</set>
where id = #{id}
</update>
set元素主要是用在更新操做的時候，它的主要功能和where元素實際上是差很少的，主要是在包含的語句前輸出一個set，而後若是包含的語句是以逗號結束的話將會把該逗號忽略，若是set包含的內容爲空的話則會出錯。有了set元素咱們就能夠動態的更新那些修改了的字段
6. foreach (在實現 mybatis in 語句查詢時特別有用)
foreach的主要用在構建in條件中，它能夠在SQL語句中進行迭代一個集合。foreach元素的屬性主要有item，index，collection，open，separator，close。item表示集合中每個元素進行迭代時的別名，index指定一個名字，用於表示在迭代過程當中，每次迭代到的位置，open表示該語句以什麼開始，separator表示在每次進行迭代之間以什麼符號做爲分隔符，close表示以什麼結束，在使用foreach的時候最關鍵的也是最容易出錯的就是collection屬性，該屬性是必須指定的，可是在不一樣狀況下，該屬性的值是不同的，主要有一下3種狀況：
若是傳入的是單參數且參數類型是一個List的時候，collection屬性值爲list
若是傳入的是單參數且參數類型是一個array數組的時候，collection的屬性值爲array
若是傳入的參數是多個的時候，咱們就須要把它們封裝成一個Map了，固然單參數也能夠封裝成map，實際上若是你在傳入參數的時候，在MyBatis裏面也是會把它封裝成一個Map的，map的key就是參數名，因此這個時候collection屬性值就是傳入的List或array對象在本身封裝的map裏面的key
1.1.單參數List的類型
程序代碼
<select id="dynamicForeachTest" resultType="Blog">
select * from t_blog where id in
<foreach collection="list" index="index" item="item" open="(" separator="," close=")">
#{item}
</foreach>
</select>
上述collection的值爲list，對應的Mapper是這樣的
程序代碼
public List<Blog> dynamicForeachTest(List<Integer> ids);
測試代碼
程序代碼
@Test
public void dynamicForeachTest() {
SqlSession session = Util.getSqlSessionFactory().openSession();
BlogMapper blogMapper = session.getMapper(BlogMapper.class);
List<Integer> ids = new ArrayList<Integer>();
ids.add(1);
ids.add(3);
ids.add(6);
List<Blog> blogs = blogMapper.dynamicForeachTest(ids);
for (Blog blog : blogs)
System.out.println(blog);
session.close();
}
2.數組類型的參數
程序代碼
<select id="dynamicForeach2Test" resultType="Blog">
select * from t_blog where id in
<foreach collection="array" index="index" item="item" open="(" separator="," close=")">
#{item}
</foreach>
</select>
對應mapper
程序代碼
public List<Blog> dynamicForeach2Test(int[] ids);
3. Map 類型的參數
程序代碼
<select id="dynamicForeach3Test" resultType="Blog">
select * from t_blog where title like "%"#{title}"%" and id in
<foreach collection="ids" index="index" item="item" open="(" separator="," close=")">
#{item}
</foreach>
</select>
mapper 應該是這樣的接口:
程序代碼
public List<Blog> dynamicForeach3Test(Map<String, Object> params);
經過以上方法，就能完成通常的mybatis 的 動態SQL 語句.最經常使用的就是 if where foreach這幾個，必定要重點掌握.
1. if 語句 (簡單的條件判斷)
2. choose (when,otherwize) ,至關於java 語言中的 switch ,與 jstl 中的choose 很相似.
3. trim (對包含的內容加上 prefix,或者 suffix 等，前綴，後綴)
4. where (主要是用來簡化sql語句中where條件判斷的，能智能的處理 and or ,沒必要擔憂多餘致使語法錯誤)
5. set (主要用於更新時)
6. foreach (在實現 mybatis in 語句查詢時特別有用)
下面分別介紹這幾種處理方式
1. mybaits if 語句處理
程序代碼
<select id="dynamicIfTest" parameterType="Blog" resultType="Blog">
select * from t_blog where 1 = 1
<if test="title != null">
and title = #{title}
</if>
<if test="content != null">
and content = #{content}
</if>
<if test="owner != null">
and owner = #{owner}
</if>
</select>
這條語句的意思很是簡單，若是你提供了title參數，那麼就要知足title=#{title}，一樣若是你提供了Content和Owner的時候，它們也須要知足相應的條件，以後就是返回知足這些條件的全部Blog，這是很是有用的一個功能，以往咱們使用其餘類型框架或者直接使用JDBC的時候， 若是咱們要達到一樣的選擇效果的時候，咱們就須要拼SQL語句，這是極其麻煩的，比起來，上述的動態SQL就要簡單多了
2.2. choose (when,otherwize) ,至關於java 語言中的 switch ,與 jstl 中的choose 很相似
程序代碼
<select id="dynamicChooseTest" parameterType="Blog" resultType="Blog">
select * from t_blog where 1 = 1
<choose>
<when test="title != null">
and title = #{title}
</when>
<when test="content != null">
and content = #{content}
</when>
<otherwise>
and owner = "owner1"
</otherwise>
</choose>
</select>
when元素表示當when中的條件知足的時候就輸出其中的內容，跟JAVA中的switch效果差很少的是按照條件的順序，當when中有條件知足的時候，就會跳出choose，即全部的when和otherwise條件中，只有一個會輸出，當全部的我很條件都不知足的時候就輸出otherwise中的內容。因此上述語句的意思很是簡單， 當title!=null的時候就輸出and titlte = #{title}，再也不往下判斷條件，當title爲空且content!=null的時候就輸出and content = #{content}，當全部條件都不知足的時候就輸出otherwise中的內容。
3.trim (對包含的內容加上 prefix,或者 suffix 等，前綴，後綴)
程序代碼
<select id="dynamicTrimTest" parameterType="Blog" resultType="Blog">
select * from t_blog
<trim prefix="where" prefixOverrides="and |or">
<if test="title != null">
title = #{title}
</if>
<if test="content != null">
and content = #{content}
</if>
<if test="owner != null">
or owner = #{owner}
</if>
</trim>
</select>
trim元素的主要功能是能夠在本身包含的內容前加上某些前綴，也能夠在其後加上某些後綴，與之對應的屬性是prefix和suffix；能夠把包含內容的首部某些內容覆蓋，即忽略，也能夠把尾部的某些內容覆蓋，對應的屬性是prefixOverrides和suffixOverrides；正由於trim有這樣的功能，因此咱們也能夠很是簡單的利用trim來代替where元素的功能
4. where (主要是用來簡化sql語句中where條件判斷的，能智能的處理 and or 條件
程序代碼
<select id="dynamicWhereTest" parameterType="Blog" resultType="Blog">
select * from t_blog
<where>
<if test="title != null">
title = #{title}
</if>
<if test="content != null">
and content = #{content}
</if>
<if test="owner != null">
and owner = #{owner}
</if>
</where>
</select>
where元素的做用是會在寫入where元素的地方輸出一個where，另一個好處是你不須要考慮where元素裏面的條件輸出是什麼樣子的，MyBatis會智能的幫你處理，若是全部的條件都不知足那麼MyBatis就會查出全部的記錄，若是輸出後是and 開頭的，MyBatis會把第一個and忽略，固然若是是or開頭的，MyBatis也會把它忽略；此外，在where元素中你不須要考慮空格的問題，MyBatis會智能的幫你加上。像上述例子中，若是title=null， 而content != null，那麼輸出的整個語句會是select * from t_blog where content = #{content}，而不是select * from t_blog where and content = #{content}，由於MyBatis會智能的把首個and 或 or 給忽略。
5.set (主要用於更新時)
程序代碼
<update id="dynamicSetTest" parameterType="Blog">
update t_blog
<set>
<if test="title != null">
title = #{title},
</if>
<if test="content != null">
content = #{content},
</if>
<if test="owner != null">
owner = #{owner}
</if>
</set>
where id = #{id}
</update>
set元素主要是用在更新操做的時候，它的主要功能和where元素實際上是差很少的，主要是在包含的語句前輸出一個set，而後若是包含的語句是以逗號結束的話將會把該逗號忽略，若是set包含的內容爲空的話則會出錯。有了set元素咱們就能夠動態的更新那些修改了的字段
6. foreach (在實現 mybatis in 語句查詢時特別有用)
foreach的主要用在構建in條件中，它能夠在SQL語句中進行迭代一個集合。foreach元素的屬性主要有item，index，collection，open，separator，close。item表示集合中每個元素進行迭代時的別名，index指定一個名字，用於表示在迭代過程當中，每次迭代到的位置，open表示該語句以什麼開始，separator表示在每次進行迭代之間以什麼符號做爲分隔符，close表示以什麼結束，在使用foreach的時候最關鍵的也是最容易出錯的就是collection屬性，該屬性是必須指定的，可是在不一樣狀況下，該屬性的值是不同的，主要有一下3種狀況：
若是傳入的是單參數且參數類型是一個List的時候，collection屬性值爲list
若是傳入的是單參數且參數類型是一個array數組的時候，collection的屬性值爲array
若是傳入的參數是多個的時候，咱們就須要把它們封裝成一個Map了，固然單參數也能夠封裝成map，實際上若是你在傳入參數的時候，在MyBatis裏面也是會把它封裝成一個Map的，map的key就是參數名，因此這個時候collection屬性值就是傳入的List或array對象在本身封裝的map裏面的key
1.1.單參數List的類型
程序代碼
<select id="dynamicForeachTest" resultType="Blog">
select * from t_blog where id in
<foreach collection="list" index="index" item="item" open="(" separator="," close=")">
#{item}
</foreach>
</select>
上述collection的值爲list，對應的Mapper是這樣的
程序代碼
public List<Blog> dynamicForeachTest(List<Integer> ids);
測試代碼
程序代碼
@Test
public void dynamicForeachTest() {
SqlSession session = Util.getSqlSessionFactory().openSession();
BlogMapper blogMapper = session.getMapper(BlogMapper.class);
List<Integer> ids = new ArrayList<Integer>();
ids.add(1);
ids.add(3);
ids.add(6);
List<Blog> blogs = blogMapper.dynamicForeachTest(ids);
for (Blog blog : blogs)
System.out.println(blog);
session.close();
}
2.數組類型的參數
程序代碼
<select id="dynamicForeach2Test" resultType="Blog">
select * from t_blog where id in
<foreach collection="array" index="index" item="item" open="(" separator="," close=")">
#{item}
</foreach>
</select>
對應mapper
程序代碼
public List<Blog> dynamicForeach2Test(int[] ids);
3. Map 類型的參數
程序代碼
<select id="dynamicForeach3Test" resultType="Blog">
select * from t_blog where title like "%"#{title}"%" and id in
<foreach collection="ids" index="index" item="item" open="(" separator="," close=")">
#{item}
</foreach>
</select>
mapper 應該是這樣的接口:
程序代碼
public List<Blog> dynamicForeach3Test(Map<String, Object> params);
經過以上方法，就能完成通常的mybatis 的 動態SQL 語句.最經常使用的就是 if where foreach這幾個，必定要重點掌握.
除非申明,文章均爲
一號門原創,轉載請註明本文地址,謝謝!
mybatis 應用程序，須要大量的配置文件，對於一個成百上千的數據庫表來講，徹底手工配置，這是一個很恐怖的工做量. 因此mybatis 官方也推出了一個mybatis代碼生成工具的jar包. 今天花了一點時間，按照 mybatis generator 的doc 文檔參考，初步配置出了一個可使用的版本，我把源代碼也提供下載,mybatis 代碼生成工具，主要有一下功能:
1.生成pojo 與 數據庫結構對應
2.若是有主鍵，能匹配主鍵
3.若是沒有主鍵，能夠用其餘字段去匹配
4.動態select,update,delete 方法
5.自動生成接口(也就是之前的dao層)
6.自動生成sql mapper，增刪改查各類語句配置，包括動態where語句配置
7.生成Example 例子供參考
下面介紹下詳細過程
1. 建立測試工程,並配置mybatis代碼生成jar包
下載地址: http://code.google.com/p/mybatis/downloads/list?can=3&q=Product%3DGenerator
mysql 驅動下載: http://dev.mysql.com/downloads/connector/j/
這些jar包，我也會包含在源代碼裏面，能夠在文章末尾處，下載源代碼，參考。
用 eclipse 創建一個dynamic web project。
解壓下載後的 mybatis-generator-core-1.3.2-bundle.zip 文件，其中有兩個目錄：一個目錄是文檔目錄docs，主要介紹這個代碼生成工具如何使用，另外一個是lib目錄，裏面的內容主要是jar 包，這裏咱們須要 mybatis-generator-core-1.3.2.jar，這個 jar 包. 將它拷貝到咱們剛剛建立的 web工程的 WebContent/WEB-INF/lib 目錄下.在這個目錄下也放入 mysql 驅動jar包.由於用 mysql 作測試的.
2.在數據庫中建立測試表
在mybatis數據庫中建立 用來測試的category表(若是沒有mybatis這個數據庫,要建立，這是基於前面這個系列文章而寫的，已經有了mybatis 這個數據庫)
程序代碼
Drop TABLE IF EXISTS `category`;
Create TABLE `category` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`catname` varchar(50) NOT NULL,
`catdescription` varchar(200) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
3. 配置mybatis 代碼生成工具的配置文件
在建立的web工程中，建立相應的package 好比 :
com.yihaomen.inter 用來存放mybatis 接口對象.
com.yihaomen.mapper用來存放sql mapper對應的映射，sql語句等.
com.yihaomen.model 用來存放與數據庫對應的model 。
在用mybatis 代碼生成工具以前，這些目錄必須先建立好，做爲一個好的應用程序，這些目錄的建立也是有規律的。
根據mybatis代碼生成工具文檔，須要一個配置文件，這裏命名爲:mbgConfiguration.xml 放在src 目錄下. 配置文件內容以下:
程序代碼
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
" http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
<!-- 配置mysql 驅動jar包路徑.用了絕對路徑 -->
<classPathEntry location="D:\Work\Java\eclipse\workspace\myBatisGenerator\WebContent\WEB-INF\lib\mysql-connector-java-5.1.22-bin.jar" />
<context id="yihaomen_mysql_tables" targetRuntime="MyBatis3">
<!-- 爲了防止生成的代碼中有不少註釋，比較難看，加入下面的配置控制 -->
<commentGenerator>
<property name="suppressAllComments" value="true" />
<property name="suppressDate" value="true" />
</commentGenerator>
<!-- 註釋控制完畢 -->
<!-- 數據庫鏈接 -->
<jdbcConnection driverClass="com.mysql.jdbc.Driver"
connectionURL="jdbc:mysql://127.0.0.1:3306/mybatis?characterEncoding=utf8"
userId="root"
password="password">
</jdbcConnection>
<javaTypeResolver >
<property name="forceBigDecimals" value="false" />
</javaTypeResolver>
<!-- 數據表對應的model 層 -->
<javaModelGenerator targetPackage="com.yihaomen.model" targetProject="src">
<property name="enableSubPackages" value="true" />
<property name="trimStrings" value="true" />
</javaModelGenerator>
<!-- sql mapper 隱射配置文件 -->
<sqlMapGenerator targetPackage="com.yihaomen.mapper" targetProject="src">
<property name="enableSubPackages" value="true" />
</sqlMapGenerator>
<!-- 在ibatis2 中是dao層，但在mybatis3中，其實就是mapper接口 -->
<javaClientGenerator type="XMLMAPPER" targetPackage="com.yihaomen.inter" targetProject="src">
<property name="enableSubPackages" value="true" />
</javaClientGenerator>
<!-- 要對那些數據表進行生成操做，必需要有一個. -->
<table schema="mybatis" tableName="category" domainObjectName="Category"
enableCountByExample="false" enableUpdateByExample="false"
enableDeleteByExample="false" enableSelectByExample="false"
selectByExampleQueryId="false">
</table>
</context>
</generatorConfiguration>
用一個main 方法來測試可否用mybatis 成生成剛剛建立的`category`表對應的model,sql mapper等內容.
建立一個com.yihaomen.test 的package ,並在此package 下面創建一個測試的類GenMain：
程序代碼
package com.yihaomen.test;
import java.io.File;
import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.exception.InvalidConfigurationException;
import org.mybatis.generator.exception.XMLParserException;
import org.mybatis.generator.internal.DefaultShellCallback;
public class GenMain {
public static void main(String[] args) {
List<String> warnings = new ArrayList<String>();
boolean overwrite = true;
String genCfg = "/mbgConfiguration.xml";
File configFile = new File(GenMain.class.getResource(genCfg).getFile());
ConfigurationParser cp = new ConfigurationParser(warnings);
Configuration config = null;
try {
config = cp.parseConfiguration(configFile);
} catch (IOException e) {
e.printStackTrace();
} catch (XMLParserException e) {
e.printStackTrace();
}
DefaultShellCallback callback = new DefaultShellCallback(overwrite);
MyBatisGenerator myBatisGenerator = null;
try {
myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
} catch (InvalidConfigurationException e) {
e.printStackTrace();
}
try {
myBatisGenerator.generate(null);
} catch (SQLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
到此爲止,eclipse項目工程圖應該以下:
4.運行測試的main 方法,生成mybatis 相關代碼
運行GenMain類裏的main方法，並刷新 工程,你會發現 各自package 目錄下已經響應生成了對應的文件，徹底符合mybatis 規則，效果圖以下:
5.注意事項
若是你想生成example 之類的東西，須要在<table></table>裏面去掉
程序代碼
enableCountByExample="false" enableUpdateByExample="false"
enableDeleteByExample="false" enableSelectByExample="false"
selectByExampleQueryId="false"
這部分配置，這是生成Example而用的，通常來講對項目沒有用.
另外生成的sql mapper 等，只是對單表的增刪改查，若是你有多表join操做，你就能夠手動配置，若是調用存儲過程，你也須要手工配置. 這時工做量已經少不少了。
若是你想用命令行方式處理，也是能夠的.
程序代碼
好比:
java -jar mybatis-generator-core-1.3.2.jar -mbgConfiguration.xm -overwrite
這時，要用絕對路徑才行. 另外mbgConfiguration.xml 配置文件中targetProject 的配置也必須是絕對路徑了。
代碼下載：
mybatis 代碼生成工具
1.生成pojo 與 數據庫結構對應
2.若是有主鍵，能匹配主鍵
3.若是沒有主鍵，能夠用其餘字段去匹配
4.動態select,update,delete 方法
5.自動生成接口(也就是之前的dao層)
6.自動生成sql mapper，增刪改查各類語句配置，包括動態where語句配置
7.生成Example 例子供參考
下面介紹下詳細過程
1. 建立測試工程,並配置mybatis代碼生成jar包
下載地址: http://code.google.com/p/mybatis/downloads/list?can=3&q=Product%3DGenerator
mysql 驅動下載: http://dev.mysql.com/downloads/connector/j/
這些jar包，我也會包含在源代碼裏面，能夠在文章末尾處，下載源代碼，參考。
用 eclipse 創建一個dynamic web project。
解壓下載後的 mybatis-generator-core-1.3.2-bundle.zip 文件，其中有兩個目錄：一個目錄是文檔目錄docs，主要介紹這個代碼生成工具如何使用，另外一個是lib目錄，裏面的內容主要是jar 包，這裏咱們須要 mybatis-generator-core-1.3.2.jar，這個 jar 包. 將它拷貝到咱們剛剛建立的 web工程的 WebContent/WEB-INF/lib 目錄下.在這個目錄下也放入 mysql 驅動jar包.由於用 mysql 作測試的.
2.在數據庫中建立測試表
在mybatis數據庫中建立 用來測試的category表(若是沒有mybatis這個數據庫,要建立，這是基於前面這個系列文章而寫的，已經有了mybatis 這個數據庫)
程序代碼
Drop TABLE IF EXISTS `category`;
Create TABLE `category` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`catname` varchar(50) NOT NULL,
`catdescription` varchar(200) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
3. 配置mybatis 代碼生成工具的配置文件
在建立的web工程中，建立相應的package 好比 :
com.yihaomen.inter 用來存放mybatis 接口對象.
com.yihaomen.mapper用來存放sql mapper對應的映射，sql語句等.
com.yihaomen.model 用來存放與數據庫對應的model 。
在用mybatis 代碼生成工具以前，這些目錄必須先建立好，做爲一個好的應用程序，這些目錄的建立也是有規律的。
根據mybatis代碼生成工具文檔，須要一個配置文件，這裏命名爲:mbgConfiguration.xml 放在src 目錄下. 配置文件內容以下:
程序代碼
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
" http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
<!-- 配置mysql 驅動jar包路徑.用了絕對路徑 -->
<classPathEntry location="D:\Work\Java\eclipse\workspace\myBatisGenerator\WebContent\WEB-INF\lib\mysql-connector-java-5.1.22-bin.jar" />
<context id="yihaomen_mysql_tables" targetRuntime="MyBatis3">
<!-- 爲了防止生成的代碼中有不少註釋，比較難看，加入下面的配置控制 -->
<commentGenerator>
<property name="suppressAllComments" value="true" />
<property name="suppressDate" value="true" />
</commentGenerator>
<!-- 註釋控制完畢 -->
<!-- 數據庫鏈接 -->
<jdbcConnection driverClass="com.mysql.jdbc.Driver"
connectionURL="jdbc:mysql://127.0.0.1:3306/mybatis?characterEncoding=utf8"
userId="root"
password="password">
</jdbcConnection>
<javaTypeResolver >
<property name="forceBigDecimals" value="false" />
</javaTypeResolver>
<!-- 數據表對應的model 層 -->
<javaModelGenerator targetPackage="com.yihaomen.model" targetProject="src">
<property name="enableSubPackages" value="true" />
<property name="trimStrings" value="true" />
</javaModelGenerator>
<!-- sql mapper 隱射配置文件 -->
<sqlMapGenerator targetPackage="com.yihaomen.mapper" targetProject="src">
<property name="enableSubPackages" value="true" />
</sqlMapGenerator>
<!-- 在ibatis2 中是dao層，但在mybatis3中，其實就是mapper接口 -->
<javaClientGenerator type="XMLMAPPER" targetPackage="com.yihaomen.inter" targetProject="src">
<property name="enableSubPackages" value="true" />
</javaClientGenerator>
<!-- 要對那些數據表進行生成操做，必需要有一個. -->
<table schema="mybatis" tableName="category" domainObjectName="Category"
enableCountByExample="false" enableUpdateByExample="false"
enableDeleteByExample="false" enableSelectByExample="false"
selectByExampleQueryId="false">
</table>
</context>
</generatorConfiguration>
用一個main 方法來測試可否用mybatis 成生成剛剛建立的`category`表對應的model,sql mapper等內容.
建立一個com.yihaomen.test 的package ,並在此package 下面創建一個測試的類GenMain：
程序代碼
package com.yihaomen.test;
import java.io.File;
import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.exception.InvalidConfigurationException;
import org.mybatis.generator.exception.XMLParserException;
import org.mybatis.generator.internal.DefaultShellCallback;
public class GenMain {
public static void main(String[] args) {
List<String> warnings = new ArrayList<String>();
boolean overwrite = true;
String genCfg = "/mbgConfiguration.xml";
File configFile = new File(GenMain.class.getResource(genCfg).getFile());
ConfigurationParser cp = new ConfigurationParser(warnings);
Configuration config = null;
try {
config = cp.parseConfiguration(configFile);
} catch (IOException e) {
e.printStackTrace();
} catch (XMLParserException e) {
e.printStackTrace();
}
DefaultShellCallback callback = new DefaultShellCallback(overwrite);
MyBatisGenerator myBatisGenerator = null;
try {
myBatisGenerator = new MyBatisGenerator(config, callback, warnings);
} catch (InvalidConfigurationException e) {
e.printStackTrace();
}
try {
myBatisGenerator.generate(null);
} catch (SQLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
到此爲止,eclipse項目工程圖應該以下:
4.運行測試的main 方法,生成mybatis 相關代碼
運行GenMain類裏的main方法，並刷新 工程,你會發現 各自package 目錄下已經響應生成了對應的文件，徹底符合mybatis 規則，效果圖以下:
5.注意事項
若是你想生成example 之類的東西，須要在<table></table>裏面去掉
程序代碼
enableCountByExample="false" enableUpdateByExample="false"
enableDeleteByExample="false" enableSelectByExample="false"
selectByExampleQueryId="false"
這部分配置，這是生成Example而用的，通常來講對項目沒有用.
另外生成的sql mapper 等，只是對單表的增刪改查，若是你有多表join操做，你就能夠手動配置，若是調用存儲過程，你也須要手工配置. 這時工做量已經少不少了。
若是你想用命令行方式處理，也是能夠的.
程序代碼
好比:
java -jar mybatis-generator-core-1.3.2.jar -mbgConfiguration.xm -overwrite
這時，要用絕對路徑才行. 另外mbgConfiguration.xml 配置文件中targetProject 的配置也必須是絕對路徑了。
代碼下載：
mybatis 代碼生成工具
除非申明,文章均爲
一號門原創,轉載請註明本文地址,謝謝!
前面的系列mybatis 文章，已經基本講到了mybatis的操做，但都是基於mapper隱射操做的，在mybatis 3中這個mapper 接口貌似充當了之前在ibatis 2中的 DAO 層的做用。但事實上，若是有這個mapper接口不能完成的工做，或者須要更復雜的擴展的時候，你就須要本身的DAO 層. 事實上 mybatis 3 也是支持DAO 層設計的，相似於ibatis 2 .下面介紹下.
在此以前，請下載 上一篇文章提供的代碼: http://www.yihaomen.com/article/java/326.htm
首先建立一個com.yihaomen.dao的package.而後在裏面分別建立接口UserDAO,以及實現該接口的UserDAOImpl
程序代碼
package com.yihaomen.dao;
import java.util.List;
import com.yihaomen.model.Article;
public interface UserDAO {
public List<Article> getUserArticles(int userid);
}
程序代碼
package com.yihaomen.dao;
import java.util.List;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import org.springframework.stereotype.Repository;
import com.yihaomen.model.Article;
@Repository
public class UserDAOImpl extends SqlSessionDaoSupport implements UserDAO {
@Override
public List<Article> getUserArticles(int userid) {
return this.getSqlSession().selectList("com.yihaomen.inter.IUserOperation.getUserArticles",userid);
}
}
執行的SQL 語句採用了命名空間+sql 語句id的方式，後面是參數.
注意繼承了 "SqlSessionDaoSupport" ，利用方法 getSqlSession() 能夠獲得 SqlSessionTemplate ,從而能夠執行各類sql語句，相似於hibernatetemplate同樣，至少思路同樣.
若是與spring 3 mvc 集成要用 autowire的話，在daoimpl 類上 加上註解 「@Repository」 ，另外還須要在spring 配置文件中加入<context:component-scan base-package="com.yihaomen.dao" /> 這樣在須要調用的地方，就可使用autowire自動注入了。
固然，你也能夠按通常程序的思路，建立一個service 的package, 用service 去調用 dao層，我這裏就沒有作了，由於比較簡單，用相似的方法，也機注意自動注入時，也要配置 <context:component-scan base-package="com.yihaomen.service" /> 等這樣的。
在controller層中測試,直接調用dao層方法
在controller中加入方法:
程序代碼
@Autowired
UserDAO userDAO;
.......
@RequestMapping("/daolist")
public ModelAndView listalldao(HttpServletRequest request,HttpServletResponse response){
List<Article> articles=userDAO.getUserArticles(1);
//制定視圖，也就是list.jsp
ModelAndView mav=new ModelAndView("list");
mav.addObject("articles",articles);
return mav;
}
這樣能夠獲得一樣的結果，並且知足了通常程序的設計方法.代碼結構以下:
在此以前，請下載 上一篇文章提供的代碼: http://www.yihaomen.com/article/java/326.htm
首先建立一個com.yihaomen.dao的package.而後在裏面分別建立接口UserDAO,以及實現該接口的UserDAOImpl
程序代碼
package com.yihaomen.dao;
import java.util.List;
import com.yihaomen.model.Article;
public interface UserDAO {
public List<Article> getUserArticles(int userid);
}
程序代碼
package com.yihaomen.dao;
import java.util.List;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import org.springframework.stereotype.Repository;
import com.yihaomen.model.Article;
@Repository
public class UserDAOImpl extends SqlSessionDaoSupport implements UserDAO {
@Override
public List<Article> getUserArticles(int userid) {
return this.getSqlSession().selectList("com.yihaomen.inter.IUserOperation.getUserArticles",userid);
}
}
執行的SQL 語句採用了命名空間+sql 語句id的方式，後面是參數.
注意繼承了 "SqlSessionDaoSupport" ，利用方法 getSqlSession() 能夠獲得 SqlSessionTemplate ,從而能夠執行各類sql語句，相似於hibernatetemplate同樣，至少思路同樣.
若是與spring 3 mvc 集成要用 autowire的話，在daoimpl 類上 加上註解 「@Repository」 ，另外還須要在spring 配置文件中加入<context:component-scan base-package="com.yihaomen.dao" /> 這樣在須要調用的地方，就可使用autowire自動注入了。
固然，你也能夠按通常程序的思路，建立一個service 的package, 用service 去調用 dao層，我這裏就沒有作了，由於比較簡單，用相似的方法，也機注意自動注入時，也要配置 <context:component-scan base-package="com.yihaomen.service" /> 等這樣的。
在controller層中測試,直接調用dao層方法
在controller中加入方法:
程序代碼
@Autowired
UserDAO userDAO;
.......
@RequestMapping("/daolist")
public ModelAndView listalldao(HttpServletRequest request,HttpServletResponse response){
List<Article> articles=userDAO.getUserArticles(1);
//制定視圖，也就是list.jsp
ModelAndView mav=new ModelAndView("list");
mav.addObject("articles",articles);
return mav;
}
這樣能夠獲得一樣的結果，並且知足了通常程序的設計方法.代碼結構以下:
相關文章
- 1. Mybatis學習記錄
- 2. mybatis 學習記錄1
- 3. MyBatis 學習記錄6 TypeHandler
- 4. SpringBoot Mybatis-Plus 學習記錄
- 5. SSM-Mybatis學習記錄（二）
- 6. Mybatis學習記錄（八）----Mybatis整合Spring
- 7. mybatis原理分析學習記錄，mybatis動態sql學習記錄
- 8. Mybatis入門：學習記錄（3）
- 9. MyBatis 學習記錄3 MapperMethod類
- 10. 2019/11/29 mybatis學習記錄
- 更多相關文章...
- • ADO 添加記錄 - ADO 教程
- • ADO 更新記錄 - ADO 教程
- • Tomcat學習筆記（史上最全tomcat學習筆記）
- • 適用於PHP初學者的學習線路和建議
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
