基於MyBatis3.0.6的基本操做介紹

時間  2019-11-06
標籤 基於 mybatis3.0.6 mybatis 基本 介紹 欄目 MyBatis 简体版
原文   原文鏈接

每 一 個 MyBatis 的 應 用 程 序 都 以 一 個 SqlSessionFactory 對 象 的 實 例 爲 核 心 。SqlSessionFactory自己是由SqlSessionFactoryBuilder建立的，通常而言，在一個應用中，一個數據庫只會對應一個SqlSessionFactory，因此通常咱們都把SqlSessionFactory定義成單例模式，或經過Spring等進行注入。java

SqlSessionFactoryBuilder建立SqlSessionFactory的方法有：sql

 

Java代碼 複製代碼  收藏代碼
  1. SqlSessionFactory build(InputStream inputStream)   
  2. SqlSessionFactory build(InputStream inputStream, String environment)   
  3. SqlSessionFactory build(InputStream inputStream, Properties properties)   
  4. SqlSessionFactory build(InputStream inputStream, String env, Properties props)   
  5. SqlSessionFactory build(Configuration config)  
SqlSessionFactory build(InputStream inputStream)
SqlSessionFactory build(InputStream inputStream, String environment)
SqlSessionFactory build(InputStream inputStream, Properties properties)
SqlSessionFactory build(InputStream inputStream, String env, Properties props)
SqlSessionFactory build(Configuration config)

 

這些方法主要設計到的參數有InputStream，environment，properties，其中InputStream是從配置文件中獲取的一個輸入流；environment表示在配置文件裏面配置的衆多的environment中，當前要使用的是哪個environment，包括數據源和事務，缺省則使用默認的environment；使用properties，MyBatis則會加載對應的屬性或文件，它們能夠在配置文件中使用。 數據庫

 

 

從XML中構建SqlSessionFactoryapache

 

Java代碼 複製代碼  收藏代碼
  1. private static SqlSessionFactory sqlSessionFactory = null;   
  2.        
  3.     static {   
  4.         try {   
  5.             InputStream is = Resources.getResourceAsStream("config/mybatis_config.xml");   
  6.             sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);   
  7.         } catch (IOException e) {   
  8.             // TODO Auto-generated catch block   
  9.             e.printStackTrace();   
  10.         }   
  11.            
  12.     }   
  13.        
  14.     public static SqlSessionFactory getSqlSessionFactory() {   
  15.         return sqlSessionFactory;   
  16.     }  
private static SqlSessionFactory sqlSessionFactory = null;
	
	static {
		try {
			InputStream is = Resources.getResourceAsStream("config/mybatis_config.xml");
			sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	
	public static SqlSessionFactory getSqlSessionFactory() {
		return sqlSessionFactory;
	}

 

下面講講配置文件的基本結構：安全

mybatis的配置文件通常包括以下幾個部分：服務器

properties：properties用於定義或導入屬性，而後在後面的環境中使用session

settings:settings用於設置一些mybatis在運行時的行爲方式，具體的設置信息能夠查看mybatis的文檔mybatis

typeAliases:typeAliases是爲系統中的Java類型指定一個較短的別名app

environments:MyBatis 能夠配置多種環境。這會幫助你將 SQL 映射應用於多種數據庫之中。ide

 

Xml代碼 複製代碼  收藏代碼
  1. <environments default="development">  
  2.         <environment id="development">  
  3.             <transactionManager type="JDBC" />  
  4.             <dataSource type="POOLED">  
  5.                 <property name="driver" value="${jdbc.driver}" />  
  6.                 <property name="url" value="${jdbc.url}" />  
  7.                 <property name="username" value="${jdbc.username}" />  
  8.                 <property name="password" value="${jdbc.password}" />  
  9.             </dataSource>  
  10.         </environment>  
  11.     </environments>  
<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC" />
			<dataSource type="POOLED">
				<property name="driver" value="${jdbc.driver}" />
				<property name="url" value="${jdbc.url}" />
				<property name="username" value="${jdbc.username}" />
				<property name="password" value="${jdbc.password}" />
			</dataSource>
		</environment>
	</environments>

因爲MyBatis能夠配置多個environment，因此能夠在建立SqlSessionFactory的時候指定具體的環境來建立特定的環境下的SqlSessionFactory，  不指定則使用默認的環境。

 

 

transactionManager

在 MyBatis 中有兩種事務管理器類型(也就是 type=」[JDBC|MANAGED]」):

  • JDBC – 這個配置直接簡單使用了 JDBC 的提交和回滾設置。 它依賴於從數據源得 到的鏈接來管理事務範圍。
  • MANAGED – 這個配置幾乎沒作什麼。它歷來不提交或回滾一個鏈接。而它會讓 容器來管理事務的整個生命週期(好比 Spring 或 JEE 應用服務器的上下文) 默認 狀況下它會關閉鏈接。 然而一些容器並不但願這樣, 所以若是你須要從鏈接中中止 它,將 closeConnection 屬性設置爲 false。

dataSource

dataSource 元素使用基本的 JDBC 數據源接口來配置 JDBC 鏈接對象的資源。

  • 許多 MyBatis 的應用程序將會按示例中的例子來配置數據源。 然而它並非必須的。 要知道爲了方便使用延遲加載,數據源纔是必須的。

有三種內建的數據源類型(也就是 type=」???」):

UNPOOLED – 這個數據源的實現是每次被請求時簡單打開和關閉鏈接。它有一點慢, 這是對簡單應用程序的一個很好的選擇, 由於它不須要及時的可用鏈接。 不一樣的數據庫對這 個的表現也是不同的, 因此對某些數據庫來講配置數據源並不重要, 這個配置也是閒置的。 UNPOOLED 類型的數據源僅僅用來配置如下 5 種屬性:

  • driver – 這是 JDBC 驅動的 Java 類的徹底限定名(若是你的驅動包含,它也不是 數據源類)。
  • url – 這是數據庫的 JDBC URL 地址。
  • username – 登陸數據庫的用戶名。
  • password – 登陸數據庫的密碼。
  • defaultTransactionIsolationLevel – 默認的鏈接事務隔離級別。

做爲可選項,你能夠傳遞數據庫驅動的屬性。要這樣作,屬性的前綴是以「driver.」開 頭的,例如:

  • driver.encoding=UTF8

這 樣 就 會 傳 遞 以 值 「 UTF8 」 來 傳 遞 屬 性 「 encoding 」, 它 是 通 過 DriverManager.getConnection(url,driverProperties)方法傳遞給數據庫驅動。

POOLED – 這是 JDBC 鏈接對象的數據源鏈接池的實現,用來避免建立新的鏈接實例 時必要的初始鏈接和認證時間。這是一種當前 Web 應用程序用來快速響應請求很流行的方 法。

除了上述(UNPOOLED)的屬性以外,還有不少屬性能夠用來配置 POOLED 數據源:

  • poolMaximumActiveConnections – 在任意時間存在的活動(也就是正在使用)連 接的數量。默認值:10
  • poolMaximumIdleConnections – 任意時間存在的空閒鏈接數。
  • poolMaximumCheckoutTime – 在被強制返回以前,池中鏈接被檢查的時間。默認 值:20000 毫秒(也就是 20 秒)
  • poolTimeToWait – 這是給鏈接池一個打印日誌狀態機會的低層次設置,還有從新 嘗試得到鏈接, 這些狀況下每每須要很長時間 爲了不鏈接池沒有配置時靜默失 敗)。默認值:20000 毫秒(也就是 20 秒)
  • poolPingQuery – 發送到數據的偵測查詢,用來驗證鏈接是否正常工做,而且準備 接受請求。默認是「NO PING QUERY SET」 ,這會引發許多數據庫驅動鏈接由一 個錯誤信息而致使失敗。
  • poolPingEnabled – 這是開啓或禁用偵測查詢。若是開啓,你必須用一個合法的 SQL 語句(最好是很快速的)設置 poolPingQuery 屬性。默認值:false。
  • poolPingConnectionsNotUsedFor – 這是用來配置 poolPingQuery 屢次時間被用一次。 這能夠被設置匹配標準的數據庫鏈接超時時間, 來避免沒必要要的偵測。 默認值: 0(也就是全部鏈接每一時刻都被偵測-但僅僅當 poolPingEnabled 爲 true 時適用)。

JNDI – 這個數據源的實現是爲了使用如 Spring 或應用服務器這類的容器, 容器能夠集 中或在外部配置數據源,而後放置一個 JNDI 上下文的引用。這個數據源配置只須要兩個屬 性:

  • initial_context – 這 個 屬 性 用 來 從 初 始 上 下 文 中 尋 找 環 境 ( 也 就 是 initialContext.lookup(initial——context) 。這是個可選屬性,若是被忽略,那麼 data_source 屬性將會直接以 initialContext 爲背景再次尋找。
  • data_source – 這是引用數據源實例位置的上下文的路徑。它會以由 initial_context 查詢返回的環境爲背景來查找,若是 initial_context 沒有返回結果時,直接以初始 上下文爲環境來查找。
再以後就是Mapper了，Mapper就是映射SQL語句的，首先要告訴mybatis要到哪裏去找這些SQL語句，即指定資源位置。
Java代碼 複製代碼  收藏代碼
  1. <mappers>   
  2.         <mapper resource="com/tiantian/mybatis/model/BlogMapper.xml"/>   
  3.     </mappers>   
<mappers>
		<mapper resource="com/tiantian/mybatis/model/BlogMapper.xml"/>
	</mappers> 

下面是我在測試過程當中的一個簡單的配置文件：
Xml代碼 複製代碼  收藏代碼
  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2. <!DOCTYPE configuration   
  3.   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"   
  4.   "http://mybatis.org/dtd/mybatis-3-config.dtd">  
  5. <configuration>  
  6.     <properties resource="config/jdbc.properties"></properties>  
  7.     <typeAliases>  
  8.         <typeAlias alias="Blog" type="com.tiantian.mybatis.model.Blog"/>  
  9.     </typeAliases>  
  10.     <environments default="development">  
  11.         <environment id="development">  
  12.             <transactionManager type="JDBC" />  
  13.             <dataSource type="POOLED">  
  14.                 <property name="driver" value="${jdbc.driver}" />  
  15.                 <property name="url" value="${jdbc.url}" />  
  16.                 <property name="username" value="${jdbc.username}" />  
  17.                 <property name="password" value="${jdbc.password}" />  
  18.             </dataSource>  
  19.         </environment>  
  20.     </environments>  
  21.     <mappers>  
  22.         <mapper resource="com/tiantian/mybatis/model/BlogMapper.xml"/>  
  23.     </mappers>  
  24. </configuration>  
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
	<properties resource="config/jdbc.properties"></properties>
	<typeAliases>
		<typeAlias alias="Blog" type="com.tiantian.mybatis.model.Blog"/>
	</typeAliases>
	<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC" />
			<dataSource type="POOLED">
				<property name="driver" value="${jdbc.driver}" />
				<property name="url" value="${jdbc.url}" />
				<property name="username" value="${jdbc.username}" />
				<property name="password" value="${jdbc.password}" />
			</dataSource>
		</environment>
	</environments>
	<mappers>
		<mapper resource="com/tiantian/mybatis/model/BlogMapper.xml"/>
	</mappers>
</configuration>
 
在上面配置文件中導入了一個外部的屬性文件，MyBatis配置文件中的屬性引入能夠是直接包含在properties元素中的，也能夠是利用properties元素從外部引入的，還能夠是在建立SqlSessionFactory的時候，做爲一個參數properties傳入。既然MyBatis配置文件中的屬性能夠從這麼多地方引入，那就牽涉到一個優先級的問題，MyBatis將會按照下面的順序來尋找它們：
  • 先是配置文件中，properties元素體中的屬性被讀取
  • 再是利用properties元素從外部引入的屬性文件中的屬性被讀取，會覆蓋前面讀取的相同的屬性
  • 最後是建立SqlSessionFactory時傳入的properties中的屬性被讀取，一樣會覆蓋前面相同的屬性

在有了SqlSessionFactory以後就是獲取特定的SqlSession了，在使用mybatis的過程當中每個操做都是離不開SqlSession的，因此獲取SqlSession是至關重要的。此外，SqlSession是不能被共享、線程不安全的，因此在每次須要SqlSession的時候都應該打開一個，而後在用完了以後再把它關上。
Java代碼 複製代碼  收藏代碼
  1. SqlSession session = sqlSessionFactory.openSession();  
SqlSession session = sqlSessionFactory.openSession();
 
SqlSessionFactory中湖區SqlSession的方法有：
Java代碼 複製代碼  收藏代碼
  1. SqlSession openSession()   
  2. SqlSession openSession(boolean autoCommit)   
  3. SqlSession openSession(Connection connection)   
  4. SqlSession openSession(TransactionIsolationLevel level)   
  5. SqlSession openSession(ExecutorType execType,TransactionIsolationLevel level)   
  6. SqlSession openSession(ExecutorType execType)   
  7. SqlSession openSession(ExecutorType execType, boolean autoCommit)   
  8. SqlSession openSession(ExecutorType execType, Connection connection)   
  9. Configuration getConfiguration();  
SqlSession openSession()
SqlSession openSession(boolean autoCommit)
SqlSession openSession(Connection connection)
SqlSession openSession(TransactionIsolationLevel level)
SqlSession openSession(ExecutorType execType,TransactionIsolationLevel level)
SqlSession openSession(ExecutorType execType)
SqlSession openSession(ExecutorType execType, boolean autoCommit)
SqlSession openSession(ExecutorType execType, Connection connection)
Configuration getConfiguration();
它們的主要區別在於：
  • Transaction (事務): 你想爲 session 使用事務或者使用自動提交
  • Connection (鏈接): 你想 MyBatis 得到來自配置的數據源的鏈接仍是提供你本身
  • Execution (執行): 你想 MyBatis 複用預處理語句和/或批量更新語句(包括插入和 刪除)
 默認的opensession方法沒有參數，它會建立有以下特性的SqlSession：
  • 會開啓一個事務，也就是不自動提交
  • 鏈接對象會從當前正在使用的environment中的數據源中獲得
  • 事務隔離級別將會使用驅動或數據源的默認值
  • 預處理語句不會被複用，也不會批量更新語句
ExecutorType有三個值：
  • ExecutorType.SIMPLE 它會爲每一個語句的執行建立一個新的預處理語句
  • ExecutorType.REUSE 它會複用預處理語句
  • ExecutorType.BATCH 這個執行器會批量執行更新語句

mybatis的基本操做就是增、刪、改、查，即insert、delete、update和select。在進行這些基本的操做的時候能夠直接利用SqlSession訪問Mapper配置文件裏面的映射來進行，也能夠利用與Mapper配置文件相對應的Mapper接口來進行操做，條件是Mapper接口中定義的方法的參數和返回值要與Mapper配置文件中定義的參數和返回值相同。此外，在使用Mapper接口的時候，對應的SQL語句是能夠寫在Mapper配置文件中的，也能夠直接利用對應的註解在Mapper接口中對應的方法上進行標明，這將在下面的示例代碼中看到。

下面是一系列的示例代碼：
先貼一個用於獲取SqlSessionFactory的工具類：
Java代碼 複製代碼  收藏代碼
  1. import java.io.IOException;   
  2. import java.io.InputStream;   
  3.   
  4. import org.apache.ibatis.io.Resources;   
  5. import org.apache.ibatis.session.SqlSessionFactory;   
  6. import org.apache.ibatis.session.SqlSessionFactoryBuilder;   
  7.   
  8. public class Util {   
  9.        
  10.     private static SqlSessionFactory sqlSessionFactory = null;   
  11.        
  12.     static {   
  13.         try {   
  14.             InputStream is = Resources.getResourceAsStream("config/mybatis_config.xml");   
  15.             sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);   
  16.         } catch (IOException e) {   
  17.             // TODO Auto-generated catch block   
  18.             e.printStackTrace();   
  19.         }   
  20.            
  21.     }   
  22.        
  23.     public static SqlSessionFactory getSqlSessionFactory() {   
  24.         return sqlSessionFactory;   
  25.     }   
  26.        
  27. }  
import java.io.IOException;
import java.io.InputStream;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class Util {
	
	private static SqlSessionFactory sqlSessionFactory = null;
	
	static {
		try {
			InputStream is = Resources.getResourceAsStream("config/mybatis_config.xml");
			sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	
	public static SqlSessionFactory getSqlSessionFactory() {
		return sqlSessionFactory;
	}
	
}
 
mybatis的配置文件：
Xml代碼 複製代碼  收藏代碼
  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2. <!DOCTYPE configuration   
  3.   PUBLIC "-//mybatis.org//DTD Config 3.0//EN"   
  4.   "http://mybatis.org/dtd/mybatis-3-config.dtd">  
  5. <configuration>  
  6.     <properties resource="config/jdbc.properties"></properties>  
  7.     <typeAliases>  
  8.         <typeAlias alias="Blog" type="com.tiantian.mybatis.model.Blog"/>  
  9.     </typeAliases>  
  10.     <environments default="development">  
  11.         <environment id="development">  
  12.             <transactionManager type="JDBC" />  
  13.             <dataSource type="POOLED">  
  14.                 <property name="driver" value="${jdbc.driver}" />  
  15.                 <property name="url" value="${jdbc.url}" />  
  16.                 <property name="username" value="${jdbc.username}" />  
  17.                 <property name="password" value="${jdbc.password}" />  
  18.             </dataSource>  
  19.         </environment>  
  20.     </environments>  
  21.     <mappers>  
  22.         <mapper resource="com/tiantian/mybatis/model/BlogMapper.xml"/>  
  23.     </mappers>  
  24. </configuration>  
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
	<properties resource="config/jdbc.properties"></properties>
	<typeAliases>
		<typeAlias alias="Blog" type="com.tiantian.mybatis.model.Blog"/>
	</typeAliases>
	<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC" />
			<dataSource type="POOLED">
				<property name="driver" value="${jdbc.driver}" />
				<property name="url" value="${jdbc.url}" />
				<property name="username" value="${jdbc.username}" />
				<property name="password" value="${jdbc.password}" />
			</dataSource>
		</environment>
	</environments>
	<mappers>
		<mapper resource="com/tiantian/mybatis/model/BlogMapper.xml"/>
	</mappers>
</configuration>
 
BlogMapper.xml
Xml代碼 複製代碼  收藏代碼
  1. <?xml version="1.0" encoding="UTF-8" ?>  
  2. <!DOCTYPE mapper   
  3.   PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"   
  4.   "http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
  5.   
  6. <mapper namespace="com.tiantian.mybatis.model.BlogMapper">  
  7. <!--  新增記錄  -->  
  8.     <insert id="insertBlog" parameterType="Blog">  
  9.         insert into t_blog(title,content,owner) values(#{title},#{content},#{owner})   
  10.     </insert>  
  11. <!--  查詢單條記錄 -->  
  12.     <select id="selectBlog" parameterType="int" resultType="Blog">  
  13.         select * from t_blog where id = #{id}   
  14.     </select>  
  15. <!--  修改記錄   -->  
  16.     <update id="updateBlog" parameterType="Blog">  
  17.         update t_blog set title = #{title},content = #{content},owner = #{owner} where id = #{id}   
  18.     </update>  
  19. <!--  查詢全部記錄，查詢多條記錄即返回結果是一個集合的時候，resultType不是集合類型，而是集合所包含的類型 -->  
  20.     <select id="selectAll" resultType="Blog">  
  21.         select * from t_blog   
  22.     </select>  
  23. <!--  模糊查詢   -->  
  24.     <select id="fuzzyQuery" resultType="Blog" parameterType="java.lang.String">  
  25.         select * from t_blog where title like "%"#{title}"%"   
  26.     </select>  
  27. <!--  刪除記錄   -->  
  28.     <delete id="deleteBlog" parameterType="int">  
  29.         delete from t_blog where id = #{id}   
  30.     </delete>  
  31. </mapper>  
<?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.tiantian.mybatis.model.BlogMapper">
<!--  新增記錄  -->
  	<insert id="insertBlog" parameterType="Blog">
  		insert into t_blog(title,content,owner) values(#{title},#{content},#{owner})
  	</insert>
<!--  查詢單條記錄	-->
	<select id="selectBlog" parameterType="int" resultType="Blog">
		select * from t_blog where id = #{id}
  	</select>
<!--  修改記錄	-->
  	<update id="updateBlog" parameterType="Blog">
  		update t_blog set title = #{title},content = #{content},owner = #{owner} where id = #{id}
  	</update>
<!--  查詢全部記錄，查詢多條記錄即返回結果是一個集合的時候，resultType不是集合類型，而是集合所包含的類型	-->
  	<select id="selectAll" resultType="Blog">
  		select * from t_blog
  	</select>
<!--  模糊查詢	-->
  	<select id="fuzzyQuery" resultType="Blog" parameterType="java.lang.String">
  		select * from t_blog where title like "%"#{title}"%"
  	</select>
<!--  刪除記錄	-->
	<delete id="deleteBlog" parameterType="int">
		delete from t_blog where id = #{id}
	</delete>
</mapper>
SQL映射語句中一些應該注意的問題：
  1.  resultType的值應該是返回類型的徹底名或別名，當返回的結果是一個集合的時候，resultType應爲集合中所包含的類型，而不是集合類型，如上面的Blog
  2. resultType和resultMap都是表示指定返回結果的，但二者不能同時使用
  3. 對於Insert映射語句有一個useGeneratedKeys屬性，該屬性的默認值爲false，當該屬性的值爲true時，在進行插入操做時，mybatis會取到當前正在插入的記錄在數據庫中的自動遞增的主鍵值，並把它設置給指定的實體的屬性，這就須要設置一個keyProperty屬性，用於指定實體中表示主鍵的屬性


Blog.java
Java代碼 複製代碼  收藏代碼
  1. package com.tiantian.mybatis.model;   
  2.   
  3. public class Blog {   
  4.   
  5.     private int id;   
  6.   
  7.     private String title;   
  8.   
  9.     private String content;   
  10.   
  11.     private String owner;   
  12.   
  13.     public int getId() {   
  14.         return id;   
  15.     }   
  16.   
  17.     public void setId(int id) {   
  18.         this.id = id;   
  19.     }   
  20.   
  21.     public String getTitle() {   
  22.         return title;   
  23.     }   
  24.   
  25.     public void setTitle(String title) {   
  26.         this.title = title;   
  27.     }   
  28.   
  29.     public String getContent() {   
  30.         return content;   
  31.     }   
  32.   
  33.     public void setContent(String content) {   
  34.         this.content = content;   
  35.     }   
  36.   
  37.     public String getOwner() {   
  38.         return owner;   
  39.     }   
  40.   
  41.     public void setOwner(String owner) {   
  42.         this.owner = owner;   
  43.     }   
  44.   
  45.     @Override  
  46.     public String toString() {   
  47.         return "id: " + id + ", title: " + title + ", content: " + content   
  48.                 + ", owner: " + owner;   
  49.     }   
  50.   
  51. }  
package com.tiantian.mybatis.model;

public class Blog {

	private int id;

	private String title;

	private String content;

	private String owner;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	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;
	}

	public String getOwner() {
		return owner;
	}

	public void setOwner(String owner) {
		this.owner = owner;
	}

	@Override
	public String toString() {
		return "id: " + id + ", title: " + title + ", content: " + content
				+ ", owner: " + owner;
	}

}
 
BlogMapper.java
Java代碼 複製代碼  收藏代碼
  1. package com.tiantian.mybatis.model;   
  2.   
  3. import java.util.List;   
  4.   
  5. import org.apache.ibatis.annotations.Delete;   
  6. import org.apache.ibatis.annotations.Insert;   
  7. import org.apache.ibatis.annotations.Select;   
  8. import org.apache.ibatis.annotations.Update;   
  9.   
  10. /**  
  11.  * 如下的操做1都是把SQL寫在配置文件裏面的，而操做2都是直接用註解標明要執行的SQL語句  
  12.  * 由於該Mapper的全名跟BlogMapper.xml文件裏面的namespace是同樣的，因此不能在這裏面  
  13.  * 用註解定義一個與BlogMapper.xml文件裏面同名的映射  
  14.  * @author andy  
  15.  *  
  16.  */  
  17. public interface BlogMapper {   
  18.   
  19.     public Blog selectBlog(int id);   
  20.        
  21.     @Select ("select * from t_blog where id = #{id}")   
  22.     public Blog selectBlog2(int id);   
  23.        
  24.     public void insertBlog(Blog blog);   
  25.        
  26.     @Insert("insert into t_blog(title,content,owner) values(#{title},#{content},#{owner})")   
  27.     public void insertBlog2(Blog blog);   
  28.        
  29.     public void updateBlog(Blog blog);   
  30.        
  31.     @Update ("update t_blog set title=#{title},content=#{content},owner=#{owner} where id=#{id}")   
  32.     public void updateBlog2(Blog blog);   
  33.        
  34.     public void deleteBlog(int id);    
  35.        
  36.     @Delete ("delete from t_blog where id = #{id}")   
  37.     public void deleteBlog2(int id);   
  38.        
  39.     public List<Blog> selectAll();   
  40.        
  41.     @Select ("select * from t_blog")   
  42.     public List<Blog> selectAll2();   
  43.        
  44.     public List<Blog> fuzzyQuery(String title);   
  45.        
  46.     @Select ("select * from t_blog where title like \"%\"#{title}\"%\"")   
  47.     public List<Blog> fuzzyQuery2(String title);   
  48.        
  49. }  
package com.tiantian.mybatis.model;

import java.util.List;

import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

/**
 * 如下的操做1都是把SQL寫在配置文件裏面的，而操做2都是直接用註解標明要執行的SQL語句
 * 由於該Mapper的全名跟BlogMapper.xml文件裏面的namespace是同樣的，因此不能在這裏面
 * 用註解定義一個與BlogMapper.xml文件裏面同名的映射
 * @author  andy
 *
 */
public interface BlogMapper {

	public Blog selectBlog(int id);
	
	@Select("select * from t_blog where id = #{id}")
	public Blog selectBlog2(int id);
	
	public void insertBlog(Blog blog);
	
	@Insert("insert into t_blog(title,content,owner) values(#{title},#{content},#{owner})")
	public void insertBlog2(Blog blog);
	
	public void updateBlog(Blog blog);
	
	@Update("update t_blog set title=#{title},content=#{content},owner=#{owner} where id=#{id}")
	public void updateBlog2(Blog blog);
	
	public void deleteBlog(int id); 
	
	@Delete("delete from t_blog where id = #{id}")
	public void deleteBlog2(int id);
	
	public List<Blog> selectAll();
	
	@Select("select * from t_blog")
	public List<Blog> selectAll2();
	
	public List<Blog> fuzzyQuery(String title);
	
	@Select("select * from t_blog where title like \"%\"#{title}\"%\"")
	public List<Blog> fuzzyQuery2(String title);
	
}
 
Test1.java
Java代碼 複製代碼  收藏代碼
  1. package com.tiantian.mybatis.test;   
  2.   
  3. import java.util.List;   
  4.   
  5. import org.apache.ibatis.session.SqlSession;   
  6. import org.junit.Test;   
  7.   
  8. import com.tiantian.mybatis.model.Blog;   
  9. import com.tiantian.mybatis.util.Util;   
  10.   
  11. /**  
  12.  * 該系列操做是經過把SQL寫在配置文件裏面，  
  13.  * 而後利用SqlSession進行操做的  
  14.  * @author andy  
  15.  *  
  16.  */  
  17. public class Test1 {   
  18.   
  19.     /**  
  20.      * 新增記錄  
  21.      */  
  22.     @Test   
  23.     public void testInsertBlog() {   
  24.         SqlSession session = Util.getSqlSessionFactory().openSession();   
  25.         Blog blog = new Blog();   
  26.         blog.setTitle("中國人");   
  27.         blog.setContent("五千年的風和雨啊藏了多少夢");   
  28.         blog.setOwner("每天");   
  29.         session.insert("com.tiantian.mybatis.model.BlogMapper.insertBlog", blog);   
  30.         session.commit();   
  31.         session.close();   
  32.     }   
  33.        
  34.     /**  
  35.      * 查詢單條記錄  
  36.      */  
  37.     @Test   
  38.     public void testSelectOne() {   
  39.         SqlSession session = Util.getSqlSessionFactory().openSession();   
  40.         Blog blog = (Blog)session.selectOne("com.tiantian.mybatis.model.BlogMapper.selectBlog", 8);   
  41.         System.out.println(blog);   
  42.         session.close();   
  43.     }   
  44.        
  45.     /**  
  46.      * 修改記錄  
  47.      */  
  48.     @Test   
  49.     public void testUpdateBlog() {   
  50.         SqlSession session = Util.getSqlSessionFactory().openSession();   
  51.         Blog blog = new Blog();   
  52.         blog.setId(7);//須要修改的Blog的id   
  53.         blog.setTitle("中國人2");//修改Title   
  54.         blog.setContent("黃色的臉，黑色的眼，不變是笑容");//修改Content   
  55.         blog.setOwner("每天2");//修改Owner   
  56.         session.update("com.tiantian.mybatis.model.BlogMapper.updateBlog", blog);   
  57.         session.commit();   
  58.         session.close();   
  59.     }   
  60.        
  61.     /**  
  62.      * 查詢全部的記錄  
  63.      */  
  64.     @Test   
  65.     public void testSelectAll() {   
  66.         SqlSession session = Util.getSqlSessionFactory().openSession();   
  67.         List<Blog> blogs = session.selectList("com.tiantian.mybatis.model.BlogMapper.selectAll");   
  68.         for (Blog blog:blogs)   
  69.             System.out.println(blog);   
  70.         session.close();   
  71.     }   
  72.        
  73.     /**  
  74.      * 模糊查詢  
  75.      */  
  76.     @Test   
  77.     public void testFuzzyQuery() {   
  78.         SqlSession session = Util.getSqlSessionFactory().openSession();   
  79.         String title = "中國";   
  80.         List<Blog> blogs = session.selectList("com.tiantian.mybatis.model.BlogMapper.fuzzyQuery", title);   
  81.         for (Blog blog:blogs)   
  82.             System.out.println(blog);   
  83.         session.close();   
  84.     }   
  85.        
  86.     /**  
  87.      * 刪除記錄  
  88.      */  
  89.     @Test   
  90.     public void testDeleteBlog() {   
  91.         SqlSession session = Util.getSqlSessionFactory().openSession();   
  92.         session.delete("com.tiantian.mybatis.model.BlogMapper.deleteBlog", 8);   
  93.         session.commit();   
  94.         session.close();   
  95.     }   
  96.        
  97. }  
package com.tiantian.mybatis.test;

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import com.tiantian.mybatis.model.Blog;
import com.tiantian.mybatis.util.Util;

/**
 * 該系列操做是經過把SQL寫在配置文件裏面，
 * 而後利用SqlSession進行操做的
 * @author  andy
 *
 */
public class Test1 {

	/**
	 * 新增記錄
	 */
	@Test 
	public void testInsertBlog() {
		SqlSession session = Util.getSqlSessionFactory().openSession();
		Blog blog = new Blog();
		blog.setTitle("中國人");
		blog.setContent("五千年的風和雨啊藏了多少夢");
		blog.setOwner("每天");
		session.insert("com.tiantian.mybatis.model.BlogMapper.insertBlog", blog);
		session.commit();
		session.close();
	}
	
	/**
	 * 查詢單條記錄
	 */
	@Test 
	public void testSelectOne() {
		SqlSession session = Util.getSqlSessionFactory().openSession();
		Blog blog = (Blog)session.selectOne("com.tiantian.mybatis.model.BlogMapper.selectBlog", 8);
		System.out.println(blog);
		session.close();
	}
	
	/**
	 * 修改記錄
	 */
	@Test 
	public void testUpdateBlog() {
		SqlSession session = Util.getSqlSessionFactory().openSession();
		Blog blog = new Blog();
		blog.setId(7);//須要修改的Blog的id
		blog.setTitle("中國人2");//修改Title
		blog.setContent("黃色的臉，黑色的眼，不變是笑容");//修改Content
		blog.setOwner("每天2");//修改Owner
		session.update("com.tiantian.mybatis.model.BlogMapper.updateBlog", blog);
		session.commit();
		session.close();
	}
	
	/**
	 * 查詢全部的記錄
	 */
	@Test 
	public void testSelectAll() {
		SqlSession session = Util.getSqlSessionFactory().openSession();
		List<Blog> blogs = session.selectList("com.tiantian.mybatis.model.BlogMapper.selectAll");
		for (Blog blog:blogs)
			System.out.println(blog);
		session.close();
	}
	
	/**
	 * 模糊查詢
	 */
	@Test 
	public void testFuzzyQuery() {
		SqlSession session = Util.getSqlSessionFactory().openSession();
		String title = "中國";
		List<Blog> blogs = session.selectList("com.tiantian.mybatis.model.BlogMapper.fuzzyQuery", title);
		for (Blog blog:blogs)
			System.out.println(blog);
		session.close();
	}
	
	/**
	 * 刪除記錄
	 */
	@Test 
	public void testDeleteBlog() {
		SqlSession session = Util.getSqlSessionFactory().openSession();
		session.delete("com.tiantian.mybatis.model.BlogMapper.deleteBlog", 8);
		session.commit();
		session.close();
	}
	
}
 
Test2.java
Java代碼 複製代碼  收藏代碼
  1. package com.tiantian.mybatis.test;   
  2.   
  3. import java.util.List;   
  4.   
  5. import org.apache.ibatis.session.SqlSession;   
  6. import org.junit.Test;   
  7.   
  8. import com.tiantian.mybatis.model.Blog;   
  9. import com.tiantian.mybatis.model.BlogMapper;   
  10. import com.tiantian.mybatis.util.Util;   
  11.   
  12. /**  
  13.  * 該系列操做是將SQL語句寫在配置文件裏面，  
  14.  * 而後經過對應Mapper接口來進行操做的  
  15.  * @author andy  
  16.  *  
  17.  */  
  18. public class Test2 {   
  19.   
  20.     /**  
  21.      * 新增記錄  
  22.      */  
  23.     @Test   
  24.     public void testInsertBlog() {   
  25.         SqlSession session = Util.getSqlSessionFactory().openSession();   
  26.         Blog blog = new Blog();   
  27.         blog.setTitle("中國人");   
  28.         blog.setContent("五千年的風和雨啊藏了多少夢");   
  29.         blog.setOwner("每天");   
  30.         BlogMapper blogMapper = session.getMapper(BlogMapper.class);   
  31.         blogMapper.insertBlog(blog);   
  32.         session.commit();   
  33.         session.close();   
  34.     }   
  35.   
  36.     /**  
  37.      * 查詢單條記錄  
  38.      */  
  39.     @Test   
  40.     public void testSelectOne() {   
  41.         SqlSession session = Util.getSqlSessionFactory().openSession();   
  42.         BlogMapper blogMapper = session.getMapper(BlogMapper.class);   
  43.         Blog blog = blogMapper.selectBlog(7);   
  44.         System.out.println(blog);   
  45.         session.close();   
  46.     }   
  47.   
  48.     /**  
  49.      * 修改記錄  
  50.      */  
  51.     @Test   
  52.     public void testUpdateBlog() {   
  53.         SqlSession session = Util.getSqlSessionFactory().openSession();   
  54.         Blog blog = new Blog();   
  55.         blog.setId(9);// 須要修改的Blog的id   
  56.         blog.setTitle("中國人2");// 修改Title   
  57.         blog.setContent("黃色的臉，黑色的眼，不變是笑容");// 修改Content   
  58.         blog.setOwner("每天2");// 修改Owner   
  59.         BlogMapper blogMapper = session.getMapper(BlogMapper.class);   
  60.         blogMapper.updateBlog(blog);   
  61.         session.commit();   
  62.         session.close();   
  63.     }   
  64.   
  65.     /**  
  66.      * 查詢全部記錄  
  67.      */  
  68.     @Test   
  69.     public void testSelectAll() {   
  70.         SqlSession session = Util.getSqlSessionFactory().openSession();   
  71.         BlogMapper blogMapper = session.getMapper(BlogMapper.class);   
  72.         List<Blog> blogs = blogMapper.selectAll();   
  73.         for (Blog blog : blogs)   
  74.             System.out.println(blog);   
  75.         session.close();   
  76.     }   
  77.   
  78.     /**  
  79.      * 模糊查詢  
  80.      */  
  81.     @Test   
  82.     public void testFuzzyQuery() {   
  83.         SqlSession session = Util.getSqlSessionFactory().openSession();   
  84.         BlogMapper blogMapper = session.getMapper(BlogMapper.class);   
  85.         String title = "中國";   
  86.         List<Blog> blogs = blogMapper.fuzzyQuery(title);   
  87.         for (Blog blog : blogs)   
  88.             System.out.println(blog);   
  89.         session.close();   
  90.     }   
  91.   
  92.     /**  
  93.      * 刪除記錄  
  94.      */  
  95.     @Test   
  96.     public void testDeleteBlog() {   
  97.         SqlSession session = Util.getSqlSessionFactory().openSession();   
  98.         BlogMapper blogMapper = session.getMapper(BlogMapper.class);   
  99.         blogMapper.deleteBlog(10);   
  100.         session.commit();   
  101.         session.close();   
  102.     }   
  103.   
  104. }  
package com.tiantian.mybatis.test;

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import com.tiantian.mybatis.model.Blog;
import com.tiantian.mybatis.model.BlogMapper;
import com.tiantian.mybatis.util.Util;

/**
 * 該系列操做是將SQL語句寫在配置文件裏面，
 * 而後經過對應Mapper接口來進行操做的
 * @author  andy
 *
 */
public class Test2 {

	/**
	 * 新增記錄
	 */
	@Test 
	public void testInsertBlog() {
		SqlSession session = Util.getSqlSessionFactory().openSession();
		Blog blog = new Blog();
		blog.setTitle("中國人");
		blog.setContent("五千年的風和雨啊藏了多少夢");
		blog.setOwner("每天");
		BlogMapper blogMapper = session.getMapper(BlogMapper.class);
		blogMapper.insertBlog(blog);
		session.commit();
		session.close();
	}

	/**
	 * 查詢單條記錄
	 */
	@Test 
	public void testSelectOne() {
		SqlSession session = Util.getSqlSessionFactory().openSession();
		BlogMapper blogMapper = session.getMapper(BlogMapper.class);
		Blog blog = blogMapper.selectBlog(7);
		System.out.println(blog);
		session.close();
	}

	/**
	 * 修改記錄
	 */
	@Test 
	public void testUpdateBlog() {
		SqlSession session = Util.getSqlSessionFactory().openSession();
		Blog blog = new Blog();
		blog.setId(9);// 須要修改的Blog的id
		blog.setTitle("中國人2");// 修改Title
		blog.setContent("黃色的臉，黑色的眼，不變是笑容");// 修改Content
		blog.setOwner("每天2");// 修改Owner
		BlogMapper blogMapper = session.getMapper(BlogMapper.class);
		blogMapper.updateBlog(blog);
		session.commit();
		session.close();
	}

	/**
	 * 查詢全部記錄
	 */
	@Test 
	public void testSelectAll() {
		SqlSession session = Util.getSqlSessionFactory().openSession();
		BlogMapper blogMapper = session.getMapper(BlogMapper.class);
		List<Blog> blogs = blogMapper.selectAll();
		for (Blog blog : blogs)
			System.out.println(blog);
		session.close();
	}

	/**
	 * 模糊查詢
	 */
	@Test 
	public void testFuzzyQuery() {
		SqlSession session = Util.getSqlSessionFactory().openSession();
		BlogMapper blogMapper = session.getMapper(BlogMapper.class);
		String title = "中國";
		List<Blog> blogs = blogMapper.fuzzyQuery(title);
		for (Blog blog : blogs)
			System.out.println(blog);
		session.close();
	}

	/**
	 * 刪除記錄
	 */
	@Test 
	public void testDeleteBlog() {
		SqlSession session = Util.getSqlSessionFactory().openSession();
		BlogMapper blogMapper = session.getMapper(BlogMapper.class);
		blogMapper.deleteBlog(10);
		session.commit();
		session.close();
	}

}
 
Test3.java
Java代碼 複製代碼  收藏代碼
  1. package com.tiantian.mybatis.test;   
  2.   
  3. import java.util.List;   
  4.   
  5. import org.apache.ibatis.session.SqlSession;   
  6. import org.junit.Test;   
  7.   
  8. import com.tiantian.mybatis.model.Blog;   
  9. import com.tiantian.mybatis.model.BlogMapper;   
  10. import com.tiantian.mybatis.util.Util;   
  11.   
  12. /**  
  13.  * 該系列操做是利用Mapper接口來進行的  
  14.  * ，然而其相應的SQL語句是經過對應的  
  15.  * 註解Annotation在Mapper中對應的方法上定義的  
  16.  * @author andy  
  17.  *  
  18.  */  
  19. public class Test3 {   
  20.   
  21.     /**  
  22.      * 新增記錄  
  23.      */  
  24.     @Test   
  25.     public void testInsert() {   
  26.         SqlSession session = Util.getSqlSessionFactory().openSession();   
  27.         BlogMapper blogMapper = session.getMapper(BlogMapper.class);   
  28.         Blog blog = new Blog();   
  29.         blog.setTitle("title2");   
  30.         blog.setContent("content2");   
  31.         blog.setOwner("owner2");   
  32.         blogMapper.insertBlog2(blog);   
  33.         session.commit();   
  34.         session.close();   
  35.     }   
  36.        
  37.     /**  
  38.      * 查找單條記錄  
  39.      */  
  40.     @Test   
  41.     public void testSelectOne() {   
  42.         SqlSession session = Util.getSqlSessionFactory().openSession();   
  43.         BlogMapper blogMapper = session.getMapper(BlogMapper.class);   
  44.         Blog blog = blogMapper.selectBlog2(1);   
  45.         System.out.println(blog);   
  46.         session.close();   
  47.     }   
  48.        
  49.     /**  
  50.      * 查找多條記錄，返回結果爲一集合  
  51.      */  
  52.     @Test   
  53.     public void testSelectAll() {   
  54.         SqlSession session = Util.getSqlSessionFactory().openSession();   
  55.         BlogMapper blogMapper = session.getMapper(BlogMapper.class);   
  56.         List<Blog> blogs = blogMapper.selectAll2();   
  57.         for (Blog blog:blogs)   
  58.             System.out.println(blog);   
  59.         session.close();   
  60.     }   
  61.        
  62.     /**  
  63.      * 修改某條記錄  
  64.      */  
  65.     @Test   
  66.     public void testUpdate() {   
  67.         SqlSession session = Util.getSqlSessionFactory().openSession();   
  68.         BlogMapper blogMapper = session.getMapper(BlogMapper.class);   
  69.         Blog blog = new Blog();   
  70.         blog.setId(3);   
  71.         blog.setTitle("title3");   
  72.         blog.setContent("content3");   
  73.         blog.setOwner("owner3");   
  74.         blogMapper.updateBlog2(blog);   
  75.         session.commit();   
  76.         session.close();   
  77.     }   
  78.        
  79.     /**  
  80.      * 刪除記錄  
  81.      */  
  82.     @Test   
  83.     public void testDelete() {   
  84.         SqlSession session = Util.getSqlSessionFactory().openSession();   
  85.         BlogMapper blogMapper = session.getMapper(BlogMapper.class);   
  86.         blogMapper.deleteBlog2(5);   
  87.         session.commit();   
  88.         session.close();   
  89.     }   
  90.        
  91.     @Test   
  92.     public void testFuzzyQuery() {   
  93.         SqlSession session = Util.getSqlSessionFactory().openSession();   
  94.         BlogMapper blogMapper = session.getMapper(BlogMapper.class);   
  95.         List<Blog> blogs = blogMapper.fuzzyQuery2("中國");   
  96.         for (Blog blog:blogs)   
  97.             System.out.println(blog);   
  98.         session.close();   
  99.     }   
  100.        
  101. }  
package com.tiantian.mybatis.test;

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import com.tiantian.mybatis.model.Blog;
import com.tiantian.mybatis.model.BlogMapper;
import com.tiantian.mybatis.util.Util;

/**
 * 該系列操做是利用Mapper接口來進行的
 * ，然而其相應的SQL語句是經過對應的
 * 註解Annotation在Mapper中對應的方法上定義的
 * @author  andy
 *
 */
public class Test3 {

	/**
	 * 新增記錄
	 */
	@Test 
	public void testInsert() {
		SqlSession session = Util.getSqlSessionFactory().openSession();
		BlogMapper blogMapper = session.getMapper(BlogMapper.class);
		Blog blog = new Blog();
		blog.setTitle("title2");
		blog.setContent("content2");
		blog.setOwner("owner2");
		blogMapper.insertBlog2(blog);
		session.commit();
		session.close();
	}
	
	/**
	 * 查找單條記錄
	 */
	@Test 
	public void testSelectOne() {
		SqlSession session = Util.getSqlSessionFactory().openSession();
		BlogMapper blogMapper = session.getMapper(BlogMapper.class);
		Blog blog = blogMapper.selectBlog2(1);
		System.out.println(blog);
		session.close();
	}
	
	/**
	 * 查找多條記錄，返回結果爲一集合
	 */
	@Test 
	public void testSelectAll() {
		SqlSession session = Util.getSqlSessionFactory().openSession();
		BlogMapper blogMapper = session.getMapper(BlogMapper.class);
		List<Blog> blogs = blogMapper.selectAll2();
		for (Blog blog:blogs)
			System.out.println(blog);
		session.close();
	}
	
	/**
	 * 修改某條記錄
	 */
	@Test 
	public void testUpdate() {
		SqlSession session = Util.getSqlSessionFactory().openSession();
		BlogMapper blogMapper = session.getMapper(BlogMapper.class);
		Blog blog = new Blog();
		blog.setId(3);
		blog.setTitle("title3");
		blog.setContent("content3");
		blog.setOwner("owner3");
		blogMapper.updateBlog2(blog);
		session.commit();
		session.close();
	}
	
	/**
	 * 刪除記錄
	 */
	@Test 
	public void testDelete() {
		SqlSession session = Util.getSqlSessionFactory().openSession();
		BlogMapper blogMapper = session.getMapper(BlogMapper.class);
		blogMapper.deleteBlog2(5);
		session.commit();
		session.close();
	}
	
	@Test 
	public void testFuzzyQuery() {
		SqlSession session = Util.getSqlSessionFactory().openSession();
		BlogMapper blogMapper = session.getMapper(BlogMapper.class);
		List<Blog> blogs = blogMapper.fuzzyQuery2("中國");
		for (Blog blog:blogs)
			System.out.println(blog);
		session.close();
	}
	
}
 


對應的建表語句：
Java代碼 複製代碼  收藏代碼
  1. CREATE TABLE `t_blog` (   
  2.   `id` int(11) NOT NULL AUTO_INCREMENT,   
  3.   `title` varchar(255) DEFAULT NULL,   
  4.   `content` varchar(255) DEFAULT NULL,   
  5.   `owner` varchar(50) DEFAULT NULL,   
  6.   PRIMARY KEY (`id`)   
  7. )  
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程