mybatis3温故

MyBatis可以利用SQL映射文件来配置，也可以利用Annotation来设置。MyBatis提供的一些基本注解如下表所示。

注解

目标

相应的XML

描述

@CacheNamespace

类

<cache>  

为给定的命名空间（比如类）配置缓存。属性：

implemetation,eviction,

flushInterval , size 和 readWrite 。

@CacheNamespaceRef

类

<cacheRef>

参照另外一个命名空间的缓存来使用。

属性：value，也就是类的完全限定名。

@ConstructorArgs

方法

<constructor>

收集一组结果传递给对象构造方法。

属性：value，是形式参数的数组

@Arg

方法

<arg>

<idArg>

 

单独的构造方法参数，是ConstructorArgs  集合的一部分。属性：id,column,javaType，typeHandler。

id属性是布尔值，来标识用于比较的属性，和<idArg>XML 元素相似

@TypeDiscriminator

方法

<discriminator>

一组实例值被用来决定结果映射的表

现。属性：Column, javaType ,  jdbcType typeHandler，cases。

cases属性就是实例的数组。

@Case

方法

<case>

单独实例的值和它对应的映射。属性：value  ，type ，results 。

Results 属性是结果数组，因此这个注解和实际的ResultMap 很相似，由下面的  Results注解指定

@Results

方法

<resultMap>

结果映射的列表，包含了一个特别结果

列如何被映射到属性或字段的详情。

属性：value ，是Result注解的数组

@Result

方法

<result>

<id>

在列和属性或字段之间的单独结果映

射。属性：id ，column ， property ，

javaType ，jdbcType ，type Handler ，

one，many。id 属性是一个布尔值，表

示了应该被用于比较的属性。one 属性是单独的联系，和 <association> 相似，而many 属性是对集合而言的，和

<collection>相似。

@One

方法

<association>  

复杂类型的单独属性值映射。属性：

select，已映射语句（也就是映射器方

法）的完全限定名，它可以加载合适类

型的实例。注意：联合映射在注解 API

中是不支持的。

@Many

方法

<collection>

复杂类型的集合属性映射。属性：

select，是映射器方法的完全限定名，它可加载合适类型的一组实例。注意：联合映射在Java注解中是不支持的。

@Options

方法

映射语句的属性

这个注解提供访问交换和配置选项的宽广范围，它们通常在映射语句上作为属性出现。而不是将每条语句注解变复杂，Options 注解提供连贯清晰的方式来访问它们。属性：useCache=true，

flushCache=false，

resultSetType=FORWARD_ONLY，

statementType=PREPARED，

fetchSize= -1，timeout=-1 ，

useGeneratedKeys=false ，

keyProperty=”id“。

理解Java 注解是很重要的，因为没有办法来指定“null ”作为值。因此，一旦你使用了Options注解，语句就受所有默认值的支配。要注意什么样的默认值来避免不期望的行为

@Insert

@Update

@Delete

方法

<insert>

<update>

<delete>

这些注解中的每一个代表了执行的真实 SQL。它们每一个都使用字符串数组（或单独的字符串）。如果传递的是字符串数组，它们由每个分隔它们的单独空间串联起来。属性：value，这是字符串数组用来组成单独的SQL语句

@InsertProvider

@UpdateProvider

@DeleteProvider

@SelectProvider

方法

<insert>

<update>

<delete>

<select>

允许创建动态

SQL。

这些可选的SQL注解允许你指定一个

类名和一个方法在执行时来返回运行

的SQL。基于执行的映射语句， MyBatis

会实例化这个类，然后执行由 provider

指定的方法. 这个方法可以选择性的接

受参数对象作为它的唯一参数，但是必

须只指定该参数或者没有参数。属性：

type，method。type 属性是类的完全限定名。method  是该类中的那个方法名。

@Param

参数

N/A

当映射器方法需多个参数，这个注解可以被应用于映射器方法参数来给每个参数一个名字。否则，多参数将会以它们的顺序位置来被命名。比如

#{1}，#{2} 等，这是默认的。

使用@Param(“person”)，SQL中参数应该被命名为#{person}。

这些注解都是运用到传统意义上映射器接口中的方法、类或者方法参数中的。

今天主要介绍两种使用注解的方式。

一种是直接在映射器接口中写SQL语句，一种是利用SqlBuilder来创建SQL再由映射器接口来调用

准备前提：

1，配置常规的MyBatis主配置文件，即各种数据源，别名等设置。在利用注解配置SQL的时候，一般不需要在主配置文件中配置Mapper，个别情况下需要配置。

2，数据库表Blog：

1
2
3
4
5
6
7
8
9
DROP  TABLE  IF EXISTS `blog`;
CREATE  TABLE  `blog` (
   `id`  int (10)  NOT  NULL  auto_increment,
   `title`  varchar (200)  NOT  NULL ,
   ` date `  varchar (50)  NOT  NULL ,
   `authername`  varchar (15)  NOT  NULL ,
   `content`  varchar (500)  NOT  NULL ,
   PRIMARY  KEY   (`id`)
) ENGINE=InnoDB  DEFAULT  CHARSET=utf8;

 数据库表User：

1
2
3
4
5
6
7
8
DROP  TABLE  IF EXISTS ` user `;
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  DEFAULT  CHARSET=utf8;

3，分别写User和Blog对应的JavaBean即setter和getter实体类。

第一种 映射器接口中写SQL语句

映射器接口注解

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package  com.whut.inter;
import  java.util.List;
import  org.apache.ibatis.annotations.Delete;
import  org.apache.ibatis.annotations.Insert;
import  org.apache.ibatis.annotations.Param;
import  org.apache.ibatis.annotations.Select;
import  org.apache.ibatis.annotations.Update;
import  com.whut.model.User;
//最基本的注解CRUD
public  interface  IUserDAO {
     @Select ( "select *from User" )
     public  List<User> retrieveAllUsers();
                                                                                                                                                                                                                                   
     //注意这里只有一个参数，则#{}中的标识符可以任意取
     @Select ( "select *from User where id=#{idss}" )
     public  User retrieveUserById( int  id);
                                                                                                                                                                                                                                   
     @Select ( "select *from User where id=#{id} and userName like #{name}" )
     public  User retrieveUserByIdAndName( @Param ( "id" ) int  id, @Param ( "name" )String names);
                                                                                                                                                                                                                                   
     @Insert ( "INSERT INTO user(userName,userAge,userAddress) VALUES(#{userName},"
             +  "#{userAge},#{userAddress})" )
     public  void  addNewUser(User user);
                                                                                                                                                                                                                                   
     @Delete ( "delete from user where id=#{id}" )
     public  void  deleteUser( int  id);
                                                                                                                                                                                                                                   
     @Update ( "update user set userName=#{userName},userAddress=#{userAddress}"
             +  " where id=#{id}" )
     public  void  updateUser(User user);
}

测试代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
package  com.whut.test;
import  java.io.IOException;
import  java.io.Reader;
import  java.util.List;
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.whut.inter.IUserDAO;
import  com.whut.model.User;
public  class  TestUser {
     private  static  SqlSessionFactory sqlSessionFactory;
     private  static  Reader reader;
     static  {
         try  {
             Reader reader = Resources.getResourceAsReader( "mybatic-config.xml" );
             sqlSessionFactory =  new  SqlSessionFactoryBuilder().build(reader);
             // 由于使用了注解，所以在主配置文件没有mapper，需要在代码里显示注册该mapper接口
             sqlSessionFactory.getConfiguration().addMapper(IUserDAO. class );
         }  catch  (IOException e) {
             e.printStackTrace();
         }
     }
     public  static  void  main(String[] args) {
         // testSelectAll();
         // testSelectByConditions();
         //testAddUser();
         //testDeleteUser();
                                                                                                                                                                                                                
         testUpateUser();
     }
     public  static  void  testSelectAll() {
         // sqlSessionFactory.getConfiguration().addMapper(IUserDAO.class);
         SqlSession session = sqlSessionFactory.openSession();
         try  {
             IUserDAO userDAO = session.getMapper(IUserDAO. class );
             List<User> users = userDAO.retrieveAllUsers();
             System.out.println( "用户编号\t"  +  "姓名\t"  +  "年龄\t住址" );
             for  (User u : users) {
                 System.out.println(u.getId() +  "\t"  + u.getUserName() +  "\t"
                         + u.getUserAge() +  "\t"  + u.getUserAddress());
             }
         }  finally  {
             session.close();
         }
     }
     public  static  void  testSelectByConditions() {
         SqlSession session = sqlSessionFactory.openSession();
         try  {
             IUserDAO userDAO = session.getMapper(IUserDAO. class );
             User u = userDAO.retrieveUserByIdAndName( 4 ,  "%spring%" );
             if  (u !=  null ) {
                 System.out.println( "用户编号\t"  +  "姓名\t"  +  "年龄\t住址" );
                 System.out.println(u.getId() +  "\t"  + u.getUserName() +  "\t"
                         + u.getUserAge() +  "\t"  + u.getUserAddress());
             }
         }  finally  {
             session.close();
         }
     }
     public  static  void  testAddUser() {
         User u =  new  User();
         u.setUserName( "dongtian" );
         u.setUserAge( 51 );
         u.setUserAddress( "hubeisheng" );
         SqlSession session = sqlSessionFactory.openSession();
         try  {
             IUserDAO userDAO = session.getMapper(IUserDAO. class );
             userDAO.addNewUser(u);
             session.commit();
         }  finally  {
             session.close();
         }
     }
     public  static  void  testDeleteUser() {
         SqlSession session = sqlSessionFactory.openSession();
         try  {
             IUserDAO userDAO = session.getMapper(IUserDAO. class );
             userDAO.deleteUser( 7 );
             session.commit();
         }  finally  {
             session.close();
         }
     }
                                                                                                                                                                                                            
     public  static  void  testUpateUser() {
         User u =  new  User();
         u.setId( 4 );
         u.setUserName( "dongtian" );
         u.setUserAge( 51 );
         u.setUserAddress( "hubeisheng" );
         SqlSession session = sqlSessionFactory.openSession();
         try  {
             IUserDAO userDAO = session.getMapper(IUserDAO. class );
             userDAO.updateUser(u);
             session.commit();
         }  finally  {
             session.close();
         }
     }
}

 

第二种 映射器接口调用SqlBuilder生成的SQL进行执行

映射器接口

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package  com.whut.inter;
import  java.util.List;
import  org.apache.ibatis.annotations.CacheNamespace;
import  org.apache.ibatis.annotations.DeleteProvider;
import  org.apache.ibatis.annotations.InsertProvider;
import  org.apache.ibatis.annotations.Options;
import  org.apache.ibatis.annotations.Param;
import  org.apache.ibatis.annotations.Result;
import  org.apache.ibatis.annotations.ResultMap;
import  org.apache.ibatis.annotations.Results;
import  org.apache.ibatis.annotations.SelectProvider;
import  org.apache.ibatis.annotations.UpdateProvider;
import  org.apache.ibatis.type.JdbcType;
import  com.whut.model.Blog;
import  com.whut.sqlTool.BlogSqlProvider;
@CacheNamespace (size= 100 )
public  interface  IBlogDAO {
     @SelectProvider (type = BlogSqlProvider. class , method =  "getSql" )
     @Results (value ={
             @Result (id= true , property= "id" ,column= "id" ,javaType=Integer. class ,jdbcType=JdbcType.INTEGER),
             @Result (property= "title" ,column= "title" ,javaType=String. class ,jdbcType=JdbcType.VARCHAR),
             @Result (property= "date" ,column= "date" ,javaType=String. class ,jdbcType=JdbcType.VARCHAR),
             @Result (property= "authername" ,column= "authername" ,javaType=String. class ,jdbcType=JdbcType.VARCHAR),
             @Result (property= "content" ,column= "content" ,javaType=String. class ,jdbcType=JdbcType.VARCHAR),
             })
     public  Blog getBlog( @Param ( "id" )  int  id);
                                                                                                                                                                                       
     @SelectProvider (type = BlogSqlProvider. class , method =  "getAllSql" )
     @Results (value ={
             @Result (id= true , property= "id" ,column= "id" ,javaType=Integer. class ,jdbcType=JdbcType.INTEGER),
             @Result (property= "title" ,column= "title" ,javaType=String. class ,jdbcType=JdbcType.VARCHAR),
             @Result (property= "date" ,column= "date" ,javaType=String. class ,jdbcType=JdbcType.VARCHAR),
             @Result (property= "authername" ,column= "authername" ,javaType=String. class ,jdbcType=JdbcType.VARCHAR),
             @Result (property= "content" ,column= "content" ,javaType=String. class ,jdbcType=JdbcType.VARCHAR),
             })
     public  List<Blog> getAllBlog();
                                                                                                                                                                                       
     @SelectProvider (type = BlogSqlProvider. class , method =  "getSqlByTitle" )
     @ResultMap (value =  "sqlBlogsMap" )
     //这里调用resultMap，这个是SQL配置文件中的,必须该SQL配置文件与本接口有相同的全限定名
     //注意文件中的namespace路径必须是使用@resultMap的类路径
     public  List<Blog> getBlogByTitle( @Param ( "title" )String title);
                                                                                                                                                                                       
     @InsertProvider (type = BlogSqlProvider. class , method =  "insertSql" )
     public  void  insertBlog(Blog blog);
                                                                                                                                                                                       
     @UpdateProvider (type = BlogSqlProvider. class , method =  "updateSql" )
     public  void  updateBlog(Blog blog);
                                                                                                                                                                                       
     @DeleteProvider (type = BlogSqlProvider. class , method =  "deleteSql" )
     @Options (useCache =  true , flushCache =  false , timeout =  10000 )
     public  void  deleteBlog( int  ids);
                                                                                                                                                                                       
}

 

SQL生成器(利用SqlBuilder生成)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package  com.whut.sqlTool;
import  java.util.Map;
import  static  org.apache.ibatis.jdbc.SqlBuilder.*;
public  class  BlogSqlProvider {
     private  final  static  String TABLE_NAME =  "blog" ;
     public  String getSql(Map<Integer, Object> parameter) {
         BEGIN();
         //SELECT("id,title,authername,date,content");
         SELECT( "*" );
         FROM(TABLE_NAME);
         //注意这里这种传递参数方式，#{}与map中的key对应，而map中的key又是注解param设置的
         WHERE( "id = #{id}" );
         return  SQL();
     }
     public  String getAllSql() {
         BEGIN();
         SELECT( "*" );
         FROM(TABLE_NAME);
         return  SQL();
     }
     public  String getSqlByTitle(Map<String, Object> parameter) {
         String title = (String) parameter.get( "title" );
         BEGIN();
         SELECT( "*" );
         FROM(TABLE_NAME);
         if  (title !=  null )
             WHERE( " title like #{title}" );
         return  SQL();
     }
     public  String insertSql() {
         BEGIN();
         INSERT_INTO(TABLE_NAME);
         VALUES( "title" ,  "#{title}" );
         //  VALUES("title", "#{tt.title}");
         //这里是传递一个Blog对象的，如果是利用上面tt.方式，则必须利用Param来设置别名
         VALUES( "date" ,  "#{date}" );
         VALUES( "authername" ,  "#{authername}" );
         VALUES( "content" ,  "#{content}" );
         return  SQL();
     }
     public  String deleteSql() {
         BEGIN();
         DELETE_FROM(TABLE_NAME);
         WHERE( "id = #{id}" );
         return  SQL();
     }
     public  String updateSql() {
         BEGIN();
         UPDATE(TABLE_NAME);
         SET( "content = #{content}" );
         WHERE( "id = #{id}" );
         return  SQL();
     }
}

 

注意由于在映射器接口中调用了@ResultMap,该注解内容是SQL配置文件ResultMap的ID，它是允许访问SQL配置文件中的ResultMap，则需要在相应的SQL配置相应ResultMap，然后再在主配置文件加上该SQL配置的Mapper路径。并且该SQL配置文件的namespace必须与使用@ResultMap的映射器接口的全限定相同。Blog.xml如下。

1
2
3
4
5
6
7
8
9
10
11
12
<? 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.whut.inter.IBlogDAO" >
    < resultMap  type = "Blog"  id = "sqlBlogsMap" >
       < id  property = "id"  column = "id" />
       < result  property = "title"  column = "title" />
       < result  property = "authername"  column = "authername" />
       < result  property = "date"  column = "date" />
       < result  property = "content"  column = "content" />
    </ resultMap >
</ mapper >

再在主配置文件mybatis-config.xml加入一句mapper。

1
2
3
< mappers >
         < mapper  resource = "com/whut/model/Blog.xml" />
</ mappers >

 

测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
package  com.whut.test;
import  java.io.IOException;
import  java.io.Reader;
import  java.util.List;
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.whut.inter.IBlogDAO;
import  com.whut.model.Blog;
/**
  * 注意这里是一种利用SqlBuilder以及多种设置来注解使用
  * @author zxl
  *
  */
public  class  TestBlog {
     private  static  SqlSessionFactory sqlSessionFactory;
     private  static  Reader reader;
     static  {
         try  {
             Reader reader = Resources.getResourceAsReader( "mybatic-config.xml" );
             sqlSessionFactory =  new  SqlSessionFactoryBuilder().build(reader);
             // 由于使用了注解，所以在主配置文件没有mapper，需要在代码里显示注册该mapper接口
             //sqlSessionFactory.getConfiguration().addMapper(IBlogDAO.class);
         }  catch  (IOException e) {
             e.printStackTrace();
         }
     }
                                                                                                                           
     public  static  void  main(String[] args) {
         //testOneBlog();
         //testAllBlog();
         //testBlogByTitle();
         //testAddBlog();
         //testDeleteBlog();
                                                                                                                               
         testUpdateBlog();
     }
                                                                                                                           
     public  static  void  testOneBlog()
     {
         SqlSession session=sqlSessionFactory.openSession();
         try {
             IBlogDAO dao=session.getMapper(IBlogDAO. class );
             Blog  blog=dao.getBlog( 2 );
             System.out.println(blog.getId()+ "\t" +blog.getAuthername()+ "\t" +blog.getTitle());
         } finally {
             session.close();
         }
                                                                                                                               
     }
     public  static  void  testAllBlog()
     {
         SqlSession session=sqlSessionFactory.openSession();
         try {
             IBlogDAO dao=session.getMapper(IBlogDAO. class );
             List<Blog>  blogs=dao.getAllBlog();
             System.out.println( "编号\t作者\t标题" );
             for (Blog blog:blogs)
             System.out.println(blog.getId()+ "\t" +blog.getAuthername()+ "\t" +blog.getTitle());
         } finally {
             session.close();
         }
     }
     public  static  void  testBlogByTitle()
     {
         SqlSession session=sqlSessionFactory.openSession();
         try {
             IBlogDAO dao=session.getMapper(IBlogDAO. class );
             List<Blog>  blogs=dao.getBlogByTitle( "%word%" );
             System.out.println( "编号\t作者\t标题" );
             for (Blog blog:blogs)
             System.out.println(blog.getId()+ "\t" +blog.getAuthername()+ "\t" +blog.getTitle());
         } finally {
             session.close();
         }
     }
                                                                                                                           
     public  static  void  testAddBlog()
     {
         SqlSession session=sqlSessionFactory.openSession();
         Blog blog= new  Blog();
         blog.setTitle( "chuntian" );
         blog.setAuthername( "xiaohua" );
         blog.setDate( "2013/12/25" );
         blog.setContent( "bushuangyayya" );
         try {
             IBlogDAO dao=session.getMapper(IBlogDAO. class );
             dao.insertBlog(blog);
             session.commit();
         } finally {
             session.close();
         }
     }
                                                                                                                           
     public  static  void  testDeleteBlog()
     {
         SqlSession session=sqlSessionFactory.openSession();
         try {
             IBlogDAO dao=session.getMapper(IBlogDAO. class );
             dao.deleteBlog( 5 );
             session.commit();
         } finally {
             session.close();
         }
     }
                                                                                                                           
     public  static  void  testUpdateBlog()
     {
         SqlSession session=sqlSessionFactory.openSession();
         Blog blog= new  Blog();
         blog.setId( 6 );
         blog.setTitle( "daxuexiaoyuan" );
         blog.setAuthername( "xiaohua" );
         blog.setDate( "2013/2/25" );
         blog.setContent( "冷死了" );
         try {
             IBlogDAO dao=session.getMapper(IBlogDAO. class );
             dao.updateBlog(blog);
             session.commit();
         } finally {
             session.close();
         }
     }
}

 

注意事项：

1） 在利用注解配置映射器接口的时候，必须要通过

sqlSessionFactory.getConfiguration().addMapper(IBlogDAO.class);来对给映射器接口注册，如果映射器接口中使用了@ResultMap注解，则由于已经在mybatis-config.xml配置了Mapper，则就不需要再次在代码中添加mapper。

2）当方法有多个参数的时候，为了与SQL语句中的#{}对应，一般可以使用@Param("")来为每个参数命别名，使得该别名与#{}对应。当参数只有一个的时候，不需要别名。

3 在进行更新删除添加的时候，如果传递的是一个实体对象，则SQL可以直接使用实体的属性。

4）映射器接口调用SqlBuilder中的方法，都是将参数转换为Map中的key，可以在SqlBuilder的方法中利用Map来获取传递的参数值，进而进行逻辑操作判断。

5）注解中对于返回多条记录的查询可以直接利用@Results和@Result来配置映射，或者利用@ResultMap来调用SQL配置文件中的ResultMap。

 

--------------------------------------------------------------------------------------------------------------------

 

 

 

 

 

 

 

 

 

 

 

 

 

 

（1）官方开发文档：http://ibatis.apache.org/docs/dotnet/datamapper/ch03s09.html

<isGreaterThan prepend="AND" property="bo.lastUpdatedBy" compareValue="0">

<![CDATA[(

LAST_UPDATED_BY=#bo.lastUpdatedBy:NUMERIC#

)]]>

</isGreaterThan>

在ibatis中，该属性用于判断传入的值是否大于0

 

<isNotNull prepend="AND" property="bo.lastUpdateDate" >

<![CDATA[(

LAST_UPDATE_DATE=#bo.lastUpdateDate:TIMESTAMP#

)]]>

</isNotNull>

在ibatis中，该属性用于判断传入的值是否为空

 

 

IBATIS动态查询语句

<!-- 在ibatis中使用安全的拼接语句,动态查询 ibatis比JDBC的优势之一,安全高效说明文字在注释中 --> <select id="selectA

<!--

在ibatis中使用安全的拼接语句,动态查询

ibatis比JDBC的优势之一,安全高效

说明文字在注释中

-->

 

 

<select id="selectAllProducts" parameterClass="Product" resultMap="ProductResult">

select id,note from Product

<dynamic prepend="WHERE">

<!-- isNotNull判断参数是否存在,Integer类型 -->

<isNotNull property="id">

<!-- isGreaterThan判断参数是否大于compareValue,isGreaterEquals是大于等于 -->

<isGreaterThan prepend=" and " property="id" compareValue="0">

id = #id#

</isGreaterThan>

</isNotNull>

<!-- isNotEmpty判断字串不为空,isEmpty可以判断字串为空 -->

<isNotEmpty prepend=" and " property="note">

<!-- 模糊查询不能用#,#在是用prepareStatement的?插入参数,$是文本替换 -->

note like '%$note$%'

</isNotEmpty>

</dynamic>

</select>

 

用Map传参数

 

<select id="selectAllProducts" parameterClass="java.util.HashMap" resultMap="ProductResult">

select id,note from Product

<dynamic prepend="WHERE">

<!-- isPropertyAvailable判断属性是否有效 -->

<isPropertyAvailable property="id">

<isNotNull property="id">

<!-- isLessThan判断参数是否小于compareValue,isLessEquals是小于等于 -->

<isLessThan prepend=" and " property="id" compareValue="10">

id = #id#

</isLessThan>

</isNotNull>

</isPropertyAvailable>

</dynamic>

</select>

<!--------------------------------------------------------------------几个常用属性-->

 

<isPropertyAvailable> 属性是存在

<isNotPropertyAvailable> 属性不存在

<isNull> 属性值是null

<isEmpty> 判断Collection.size<1或String.length()<1

<isEqual> 等于

<isNotEqual> 不等于

<isGreaterThan> 大于

<isGreaterEqual> 大于等于

<isLessThan> 小于

<isLessEqual> 小于等于


ibatis中使用安全的拼接语句,动态查询,大于、小于、等于

2012-11-26 17:38:13| 分类： 默认分类 |举报|字号 订阅
在ibatis中使用安全的拼接语句,动态查询
ibatis比JDBC的优势之一,安全高效
说明文字在注释中

<select id="selectAllProducts" parameterClass="Product" resultMap="ProductResult">
select id,note from Product
<dynamic prepend="WHERE">
<!-- isNotNull判断参数是否存在,Integer类型 -->
<isNotNull property="id">
<!-- isGreaterThan判断参数是否大于compareValue,isGreaterEquals是大于等于 -->
<isGreaterThan prepend=" and " property="id" compareValue="0">
id = #id#
</isGreaterThan>
</isNotNull>
<!-- isNotEmpty判断字串不为空,isEmpty可以判断字串为空 -->
<isNotEmpty prepend=" and " property="note">
<!-- 模糊查询不能用#,#在是用prepareStatement的?插入参数,$是文本替换 -->
note like '%$note$%'
</isNotEmpty>
</dynamic>
</select>

用Map传参数

<select id="selectAllProducts" parameterClass="java.util.HashMap" resultMap="ProductResult">
select id,note from Product
<dynamic prepend="WHERE">
<!-- isPropertyAvailable判断属性是否有效 -->
<isPropertyAvailable property="id">
<isNotNull property="id">
<!-- isLessThan判断参数是否小于compareValue,isLessEquals是小于等于 -->
<isLessThan prepend=" and " property="id" compareValue="10">
id = #id#
</isLessThan>
</isNotNull>
</isPropertyAvailable>
</dynamic>
</select>
/*动态SQL的参数有

属性关键字
含义

<isEqual>
如果参数相等于值则查询条件有效。

<isNotEqual>
如果参数不等于值则查询条件有效。

<isGreaterThan>
如果参数大于值则查询条件有效。

<isGreaterEqual>
如果参数等于值则查询条件有效。

<isLessEqual>
如果参数小于值则查询条件有效。如下所示：

<isLessEqual prepend = ”AND” property = ”age” compareValue = ”18” >

ADOLESCENT = ‘TRUE’

</isLessEqual>

<isPropertyAvailable>
如果参数有使用则查询条件有效。

<isNotPropertyAvailable>
如果参数没有使用则查询条件有效。

<isNull>
如果参数为NULL则查询条件有效。

<isNotNull>
如果参数不为NULL则查询条件有效。

<isEmpty>
如果参数为空则查询条件有效。

<isNotEmpty>
如果参数不为空则查询条件有效。参数的数据类型为Collection、String 时参数不为NULL或“”。如下所示：

<isNotEmpty prepend=”AND” property=”firstName” >

FIRST_NAME=#firstName#

</isNotEmpty>

<isParameterPresent>
如果参数类不为NULL则查询条件有效。

<isNotParameterPresent>
Checks to see if the parameter object is not present (null). Example Usage:

<isNotParameterPresent prepend=”AND”>

EMPLOYEE_TYPE = ‘DEFAULT’

</isNotParameterPresent>


在复杂查询过程中，我们常常需要根据用户的选择决定查询条件，这里发生变化的并不只是SQL 中的参数，包括Select 语句中所包括的字段和限定条件，都可能发生变化。典型情况，如在一个复杂的组合查询页面，我们必须根据用户的选择和输入决定查询的条件组合。

一个典型的页面如下：

对于这个组合查询页面，根据用户选择填写的内容，我们应为其生成不同的查询语句。如用户没有填写任何信息即提交查询请求，我们应该返回所有记录：
Select * from t_user；
如用户只在页面上填写了姓名“Erica”，我们应该生成类似：
Select * from t_user where name like ‘%Erica%’ ；的SQL查询语句。
如用户只在页面上填写了地址“Beijing”，我们应该生成类似：
Select * from t_user where address like ‘%Beijing%”；的SQL。
而如果用户同时填写了姓名和地址（”Erica”&’Beijing’），则我们应生成类似：
Select * from t_user where name like ‘%Erica%’ and address like ‘%Beijing%”的SQL查询语句。

对于ibatis 这样需要预先指定SQL 语句的ORM 实现而言，传统的做法无非通过if-else 语句对输入参数加以判定，然后针对用户选择调用不同的statement 定义。对于上面这种简单的情况（两种查询条件的排列组合，共4 种情况）而言，statement 的重复定义工作已经让人不厌其烦，而对于动辄拥有七八个查询条件，乃至十几个查询条件
的排列组合而言，琐碎反复的statement定义实在让人不堪承受。

考虑到这个问题，ibatis引入了动态映射机制，即在statement定义中，根据不同的
查询参数，设定对应的SQL语句。
还是以上面的示例为例：
<select id="getUsers"
parameterClass="user"
resultMap="get-user-result">
select
id,
name,
sex
from t_user
<dynamic prepend="WHERE">
<isNotEmpty prepend="AND" property="name">
(name like #name#)
</isNotEmpty>
<isNotEmpty prepend="AND" property="address">
(address like #address#)
</isNotEmpty>
</dynamic>
</select>
通过dynamic 节点，我们定义了一个动态的WHERE 子句。此WHERE 子句中将
可能包含两个针对name 和address 字段的判断条件。而这两个字段是否加入检索取决于用户所提供的查询条件（字段是否为空[isNotEmpty]）。
对于一个典型的Web程序而言，我们通过HttpServletRequest获得表单中的字段名并将其设入查询参数，如：
user.setName(request.getParameter("name"));
user.setAddress(request.getParameter("address"));
sqlMap.queryForList("User.getUsers", user);
在执行queryForList("User.getUsers", user)时，ibatis 即根据配置文
件中设定的SQL动态生成规则，创建相应的SQL语句。
上面的示例中，我们通过判定节点isNotEmpty，指定了关于name 和address 属
性的动态规则：
<isNotEmpty prepend="AND" property="name">
(name like #name#)
</isNotEmpty>
这个节点对应的语义是，如果参数类的"name"属性非空（isNotEmpty，即非空
字符串””），则在生成的SQL Where字句中包括判定条件(name like #name#)，其
中#name#将以参数类的name属性值填充。
Address属性的判定生成与name属性完全相同，这里就不再赘述。
这样，我们通过在statement 定义中引入dynamic 节点，很简单的实现了SQL 判定子句的动态生成，对于复杂的组合查询而言，这将带来极大的便利。判定节点的定义可以非常灵活，我们甚至可以使用嵌套的判定节点来实现复杂的动态映射，如：
<isNotEmpty prepend="AND" property="name">
( name=#name#
<isNotEmpty prepend="AND" property="address">
address=#address#
</isNotEmpty>
)
</isNotEmpty>
这段定义规定，只有用户提供了姓名信息时，才能结合地址数据进行查询（如果只提供地址数据，而将姓名信息忽略，将依然被视为全检索）。Dynamic节点和判定节点中的prepend属性，指明了本节点中定义的SQL子句在
主体SQL中出现时的前缀。如：

<dynamic prepend="WHERE">
<isNotEmpty prepend="AND" property="name">
(name like #name#)
</isNotEmpty>
<isNotEmpty prepend="AND" property="address">
(address like #address#)
</isNotEmpty>
</dynamic>

假设"name"属性的值为“Erica”, "address"属性的值为“Beijing”，则会生成类似下面的SQL子句（实际运行期将生成带占位符的PreparedStatement，之后再为其填充数据）：

WHERE (name like ‘Beijing’) AND (address like ‘Beijing’)

其中WHERE 之后的语句是在dynamic 节点中所定义，因此以dynamic 节点的prepend设置（"WHERE"）作为前缀，而其中的”AND”，实际上是address属性所对应的isNotEmpty节点的prepend设定，它引领了对应节点中定义的SQL子句。至于name属性对应的isNotEmpty节点，由于ibatis会自动判定是否需要追加prepend前缀，这里(name like #name#)是WHERE 子句中的第一个条件子句，无需AND 前缀，所以自动省略。

判定节点并非仅限于isNotEmpty，ibatis中提供了丰富的判定定义功能。判定节点分两类：

? 一元判定
一元判定是针对属性值本身的判定，如属性是否为NULL，是否为空值等。
上面示例中isNotEmpty就是典型的一元判定。

一元判定节点有：

节点名 描述
<isPropertyAvailable> 参数类中是否提供了此属性
<isNotPropertyAvailable> 与<isPropertyAvailable>相反
<isNull> 属性值是否为NULL
<isNotNull> 与<isNull>相反
<isEmpty> 如果属性为Collection或者String，其size是否<1，如果非以上两种类型，则通过String.valueOf(属性值)
获得其String类型的值后，判断其size是否<1<isNotEmpty> 与<isEmpty>相反。

? 二元判定
二元判定有两个判定参数，一是属性名，而是判定值，如
<isGreaterThan prepend="AND" property="age"
compareValue="18">
(age=#age#)
</isGreaterThan>
其中，property="age"指定了属性名”age”，compareValue=”18”指明了判定值为”18”。上面判定节点isGreaterThan 对应的语义是：如果age 属性大于18(compareValue)，则在SQL中加入(age=#age#)条件。
二元判定节点有：
节点名 属性值与compareValues的关系
<isEqual> 相等。
<isNotEqual> 不等。
<isGreaterThan> 大于
<isGreaterEqual> 大于等于
<isLessThan> 小于
<isLessEqual> 小于等于

 


为了防止SQL注入，iBatis模糊查询时也要避免使用$$来进行传值。下面是三个不同数据库的ibatis的模糊查询传值。
mysql: select * from stu where name like concat('%',#name #,'%')

oracle: select * from stu where name like '%'||#name #||'%'

SQL Server:select * from stu where name like '%'+#name #+'%
如：
<!-- 用途：小二后台查询活动的数目 -->
<!-- 频率：1000/天 -->
<!-- 维护：刘飞 -->
<select id="countActivitySearch" resultClass="java.lang.Long" parameterClass="actDO">
<![CDATA[
select count(id) from activity
]]>

<dynamic prepend="WHERE">
<isNotNull prepend=" AND " property="name">
name LIKE CONCAT('%', #name#, '%')
</isNotNull>
<isNotNull prepend=" AND " property="itemId">
itemId = #itemId#
</isNotNull>
<isNotNull prepend=" AND " property="itemName">
itemName LIKE CONCAT('%', #itemName#, '%')
</isNotNull>
<isNotNull prepend=" AND " property="status">
status = #status#
</isNotNull>
<isNotNull prepend=" AND " property="actStatus">
actStatus = #actStatus#
</isNotNull>
<isNotNull prepend=" AND " property="domain">
domain LIKE CONCAT('%', #domain#, '%')
</isNotNull>
</dynamic>

</select>

<!-- 用途：小二后台查询活动的列表 -->
<!-- 频率：1000/天 -->
<!-- 维护：刘飞 -->
<select id="searchActivityForList" resultMap="actResult" parameterClass="actDO">
<![CDATA[
select * from activity
]]>

<dynamic prepend="WHERE">
<isNotNull prepend=" AND " property="name">
name LIKE CONCAT('%', #name#, '%')
</isNotNull>
<isNotNull prepend=" AND " property="itemId">
itemId = #itemId#
</isNotNull>
<isNotNull prepend=" AND " property="itemName">
itemName LIKE CONCAT('%', #itemName#, '%')
</isNotNull>
<isNotNull prepend=" AND " property="status">
status = #status#
</isNotNull>
<isNotNull prepend=" AND " property="actStatus">
actStatus = #actStatus#
</isNotNull>
<isNotNull prepend=" AND " property="domain">
domain LIKE CONCAT('%', #domain#, '%')
</isNotNull>
</dynamic>

<![CDATA[
order by starttime desc, createtime desc
limit
#startRow#, #perPageSize#
]]>
</select>

 


IBatis模糊查詢

<!--
在ibatis中使用安全的拼接语句,动态查询
ibatis比JDBC的优势之一,安全高效
说明文字在注释中
-->


<select id="selectAllProducts" parameterClass="Product" resultMap="ProductResult">
select id,note from Product
<dynamic prepend="WHERE">
<!-- isNotNull判断参数是否存在,Integer类型 -->
<isNotNull property="id">
<!-- isGreaterThan判断参数是否大于compareValue,isGreaterEquals是大于等于 -->
<isGreaterThan prepend=" and " property="id" compareValue="0">
id = #id#
</isGreaterThan>
</isNotNull>
<!-- isNotEmpty判断字串不为空,isEmpty可以判断字串为空 -->
<isNotEmpty prepend=" and " property="note">
<!-- 模糊查询不能用#,#在是用prepareStatement的?插入参数,$是文本替换 -->
note like '%$note$%'
</isNotEmpty>
</dynamic>
</select>

用Map传参数

<select id="selectAllProducts" parameterClass="java.util.HashMap" resultMap="ProductResult">
select id,note from Product
<dynamic prepend="WHERE">
<!-- isPropertyAvailable判断属性是否有效 -->
<isPropertyAvailable property="id">
<isNotNull property="id">
<!-- isLessThan判断参数是否小于compareValue,isLessEquals是小于等于 -->
<isLessThan prepend=" and " property="id" compareValue="10">
id = #id#
</isLessThan>
</isNotNull>
</isPropertyAvailable>
</dynamic>
</select>
<!--------------------------------------------------------------------几个常用属性-->

<isPropertyAvailable> 属性是存在
<isNotPropertyAvailable> 属性不存在
<isNull> 属性值是null
<isEmpty> 判断Collection.size<1或String.length()<1
<isEqual> 等于
<isNotEqual> 不等于
<isGreaterThan> 大于
<isGreaterEqual> 大于等于
<isLessThan> 小于
<isLessEqual>

---------------------

Ibatis的动态查询使得数据操作变得非常的灵活，下次举出了常用的动态查询的属性信息： 
Ibatis配置信息 

Xml代码   收藏代码
  1. <!-- Dynamic Sql -->  
  2.   <typeAlias alias="Student" type="com.ibatis.Student" />  
  3.     <typeAlias alias="StudentDTO" type="com.ibatis.StudentDTO" />  
  4.     <select id="dynamicGetStudent" parameterClass="StudentDTO"  
  5.         resultClass="Student">  
  6.         select *  
  7.         from student  
  8.         <dynamic prepend="WHERE">  
  9.             <isNotEqual prepend="AND" property="sid" compareValue="0">  
  10.                 sid = #sid#  
  11.             </isNotEqual>  
  12.               
  13.             <isNotNull prepend="AND" property="sname">  
  14.                 sname = #sname#  
  15.             </isNotNull>  
  16.         </dynamic>  
  17.         <dynamic prepend="order by">  
  18.             <isParameterPresent>  
  19.                 <isEqual prepend="order by" property="sort" compareValue="1">  
  20.                     sname desc,socre  
  21.                 </isEqual>  
  22.                   
  23.                 <isEqual prepend="order by" property="sort" compareValue="2">  
  24.                     sname asc,socre  
  25.                 </isEqual>  
  26.             </isParameterPresent>  
  27.         </dynamic>  
  28.     </select>  


Student的信息 

Java代码   收藏代码
  1. package com.ibatis;  
  2.   
  3. import java.util.Date;  
  4.   
  5. public class Student {  
  6.     private int sid;  
  7.     private String sname;  
  8.     private String major;  
  9.     private Date birth;  
  10.     private int socre;  
  11.     public int getSid() {  
  12.         return sid;  
  13.     }  
  14.     public void setSid(int sid) {  
  15.         this.sid = sid;  
  16.     }  
  17.     public String getSname() {  
  18.         return sname;  
  19.     }  
  20.     public void setSname(String sname) {  
  21.         this.sname = sname;  
  22.     }  
  23.     public String getMajor() {  
  24.         return major;  
  25.     }  
  26.     public void setMajor(String major) {  
  27.         this.major = major;  
  28.     }  
  29.     public Date getBirth() {  
  30.         return birth;  
  31.     }  
  32.     public void setBirth(Date birth) {  
  33.         this.birth = birth;  
  34.     }  
  35.     public int getSocre() {  
  36.         return socre;  
  37.     }  
  38.     public void setSocre(int socre) {  
  39.         this.socre = socre;  
  40.     }  
  41.       
  42.     @Override  
  43.     public String toString() {  
  44.         String content = "Sid="+this.sid+"\t"+"Sname="+this.sname+"\t"+this.birth.toLocaleString();  
  45.         return content;  
  46.     }  
  47.       
  48. }  


StudentDTO的信息 

Java代码   收藏代码
  1. package com.ibatis;  
  2.   
  3. import java.util.Date;  
  4.   
  5. public class StudentDTO {  
  6.     private int sid;  
  7.     private String sname;  
  8.     private String major;  
  9.     private Date birth;  
  10.     private int socre;  
  11.     private int sort;  
  12.     public int getSort() {  
  13.         return sort;  
  14.     }  
  15.     public void setSort(int sort) {  
  16.         this.sort = sort;  
  17.     }  
  18.     public int getSid() {  
  19.         return sid;  
  20.     }  
  21.     public void setSid(int sid) {  
  22.         this.sid = sid;  
  23.     }  
  24.     public String getSname() {  
  25.         return sname;  
  26.     }  
  27.     public void setSname(String sname) {  
  28.         this.sname = sname;  
  29.     }  
  30.     public String getMajor() {  
  31.         return major;  
  32.     }  
  33.     public void setMajor(String major) {  
  34.         this.major = major;  
  35.     }  
  36.     public Date getBirth() {  
  37.         return birth;  
  38.     }  
  39.     public void setBirth(Date birth) {  
  40.         this.birth = birth;  
  41.     }  
  42.     public int getSocre() {  
  43.         return socre;  
  44.     }  
  45.     public void setSocre(int socre) {  
  46.         this.socre = socre;  
  47.     }  
  48.       
  49.     @Override  
  50.     public String toString() {  
  51.         String content = "Sid="+this.sid+"\t"+"Sname="+this.sname+"\t"+this.birth.toLocaleString();  
  52.         return content;  
  53.     }  
  54.       
  55. }  


Java中的调用信息 

Java代码   收藏代码
  1. @SuppressWarnings("unchecked")  
  2.     public static void main(String[] args) {  
  3.         List<Student> list = dao.dynamicGetStudent(studentDTO);  
  4.         for(Student student : list){  
  5.             System.out.println("name:"+student.getSname());  
  6.         }  
  7.         System.out.println("size:"+list.size());  
  8.     }  
  9. @Override  
  10.     public List dynamicGetStudent(StudentDTO studentDTO) {  
  11.         List result = null;  
  12.         try {  
  13.             result = sqlMapClient.queryForList("dynamicGetStudent",studentDTO);  
  14.         } catch (SQLException e) {  
  15.             // TODO Auto-generated catch block  
  16.             e.printStackTrace();  
  17.         }  
  18.         return result;  
  19.     }  


动态查询中的常用属性： 

 

属性关键字 含义
<isEqual> 如果参数相等于值则查询条件有效
<isNotEqual> 如果参数不等于值则查询条件有效
<isGreaterThan> 如果参数大于值则查询条件有效
<isGreaterEqual> 如果参数等于值则查询条件有效
<isLessEqual> 如果参数小于值则查询条件有效。如下所示：<isLessEqual prepend = ”AND” property = ”age” compareValue = ”18” >ADOLESCENT = ‘TRUE’</isLessEqual>
<isPropertyAvailable> 如果参数有使用则查询条件有效。
<isNotPropertyAvailable> 如果参数没有使用则查询条件有效
<isNull> 如果参数为NULL则查询条件有效
<isNotNull> 如果参数不为NULL则查询条件有效
<isEmpty> 如果参数为空则查询条件有效
<isNotEmpty> 如果参数不为空则查询条件有效
<isParameterPresent> 如果参数类不为NULL则查询条件有效
<isNotParameterPresent> Checks to see if the parameter object is not present (null). Example Usage

你可能感兴趣的:(Mybatis3)

  • MyBatis简单配置 T何必当初 Java后端框架mybatisjavamysql
    1、在Maven的pom.xml中导入Mybatis和MySQL数据库驱动依赖org.mybatismybatis3.5.5mysqlmysql-connector-java5.1.382、在Maven项目中的resources下创建mybatis-config.xml配置文件-->3、在com.tyh.utils下创建MybatisUtils.java工具类packagecom.tyh.util
  • Mmybatis xml 连接数据库的方法 墨香染城城 xml数据库
    1.添加依赖（Maven项目）在pom.xml中添加MyBatis和数据库驱动的依赖（以MySQL为例）：org.mybatismybatis3.5.13mysqlmysql-connector-java8.0.332.配置MyBatis核心文件在resources目录下创建mybatis-config.xml，配置数据库连接和全局设置：3.创建实体类定义与数据库表对应的实体类，例如User：pu
  • Mybaties中配置C3P0连接池 yuren_xia 后端技术mybatiesC3P0JAVA
    在MyBatis中配置C3P0连接池，你需要确保已经添加了C3P0和MyBatis的依赖，并在MyBatis的配置文件中正确配置了数据源。以下是一个基本的步骤指南：1.添加依赖如果你使用Maven，可以在pom.xml中添加以下依赖：org.mybatismybatis3.5.7com.mchangec3p00.9.5.5mysqlmysql-connector-java8.0.232.创建数据源
  • Spring整合Mybatis(配置类实现) 小王就爱报错 springmybatisjava
    一、引入所需依赖org.springframeworkspring-context5.3.31org.mybatismybatis3.5.15org.mybatismybatis-spring2.0.7org.springframeworkspring-jdbc5.1.9.RELEASEmysqlmysql-connector-java8.0.33junitjunit4.13.2testcom.a
  • springboot启动报错：java.lang.NoClassDefFoundError: javax/websocket/DeploymentException 雾林小妖 Java项目应用springbootjavawebsocket
    1、问题概述？在项目开发中遇到了一件非常有趣的事情。我在本机的开发环境是：springboot2.2.2+webscoket+mysql5.7+mybatis3.5.3.2版本。开发结束后，我将项目部署到了另一台机器上面，这台机器是windows11，本来就是想将环境复制一份到这台机器上，结果出了下面的一个bug提示。这是少数花费了大量时间，最终发现问题所在。java.lang.NoClassDe
  • SpringBoot Mybatis 配置文件形式 ceaningking SpringBootmybatisspringboot配置集成
    开发环境:IDEA2022.1.4+Mybatis目录1.概述2.单独配置mybatis-config.xml2.1配置内容2.2辅助类2.3调用操作3.application.yml配置mybatis3.1配置内容3.2辅助类3.3调用操作4.结语1.概述在之前BiliBili学习SprintBoot时候，按照视频敲代码，SpringBoot集成MyBatis，是单独写了一个mybatis-co
  • 黑马程序员spring整合Mybatis&Junit&Druid 闲易生事 mybatisspringjava
    准备工作1.Maven导入依赖org.springframeworkspring-context5.2.10.RELEASEorg.mybatismybatis3.5.6mysqlmysql-connector-java5.1.47org.mybatis
  • MyBatis学习笔记 繁星依月 开发技术学习笔记mybatis学习笔记
    MyBatis学习笔记MyBatis绪论功能：访问数据库相当于增强版JDBC官网：mybatis–MyBatis3|简介MyBatis环境JDK1.8MySQL5.7/8.0（经典！）maven3.6+IDEAMyBatis前序JDBC、MySQL、Java基础、Maven、JunitMyBatis简介什么是MyBatisMyBatis是一款优秀的持久层框架，它支持自定义SQL、存储过程以及高级映
  • 【图书介绍】《Spring+Spring MVC+MyBatis从零开始学（视频教学版）（第3版）》 夏天又到了 编程与应用开发Spring开发springmvcmybatis
    本书重点基于版本Spring6.1.10、SpringMVC6.1.10、MyBatis3.5.16。详解SSM框架各组件用法及其整合方法，实战新闻发布管理系统、图书管理系统开发。配套示例源码、PPT课件、教学大纲、习题答案、教学视频。内容简介本书全面讲解使用流行轻量级框架SSM（Spring+SpringMVC+MyBatis）进行JavaEEWeb开发的技术，并以综合案例“学生选课管理系统”为
  • Springboot3 整合 Mybatis3 （前程似锦） mybatisjavaspringboot
    Springboot3整合MybatisSpringboot3整合MybatisSpringboot3整合Mybatis一、导入依赖二、编写配置文件三、定义模型entity实体类四、在启动类上添加注解，表示mapper接口所在位置五、定义mapper接口六、定义mapper.xml映射文件七、service层八、测试一、导入依赖mybatis的必要依赖注意：使用springboot3的话要使用my
  • 第五章 SqlSession 的创建过程 flying jiang MyBatis3源码深度解析javatomcatmybatis
    在MyBatis3中，SqlSession的创建过程涉及到对MyBatis配置文件的解析，这通常是通过XPath（XMLPathLanguage）来完成的。XPath是一种在XML文档中查找信息的语言，MyBatis使用它来解析配置文件（如mybatis-config.xml）中的元素和属性。以下是SqlSession创建过程中XPath使用的简要概述：读取配置文件：MyBatis首先需要读取其配
  • MyBatis从浅入深 下水道程序员 mybatis
    MyBatis简介Mybatis用于简化Java当中对于JDBC的操作，它将连接数据库，执行SQL命令自动化实现框架创建创建Maven工程引入三个依赖Mybatis核心junit测试MySQL驱动org.mybatismybatis3.5.7junitjunit4.12testmysqlmysql-connector-java5.1.3根据需要可以更改版本之类的东西创建Mybatis核心文件习惯上
  • MyBatis框架搭建(利用Maven技术) 秋意钟 mybatismavenjava
    一、pom.xml配置文件导入MyBatis框架包以及所需仓库（Maven技术在云端下载）4.0.0com.bdqnT369-MyBatiswar1.0-SNAPSHOTT369-MyBatisMavenWebapphttp://maven.apache.orgcom.mysqlmysql-connector-j8.2.0org.mybatismybatis3.5.16log4jlog4j1.2.
  • Spring 集成 MyBatis 花下的晚风 java后端转后厨springmybatisjava
    sping6,mybatis3.5.10,maven3.6.1第一步，引入依赖，引入sping6仓库若引入失败可以手动下载好jar包粘贴到本地maven仓库的对应位置org.springframeworkspring-context6.0.0-M2org.springframeworkspring-jdbc6.0.0-M2mysqlmysql-connector-java8.0.31org.myb
  • MyBatis基本使用方法 javapostgresql
    使用PostgreSQL数据库与MyBatis结合的方法涉及配置数据库连接、编写Mapper接口和SQL语句、以及整合这些组件。以下是一个简单的步骤指南，以便在Java项目中使用MyBatis访问PostgreSQL数据库：步骤1:添加依赖确保你的项目中包含了以下依赖：org.mybatismybatis3.x.xorg.postgresqlpostgresql42.x.x步骤2:配置数据库连接在
  • spring快速入门--整合mybatis 骑驴那小子 springjavajava-ee
    Spring整合mybatis1、添加依赖org.springframeworkspring-webmvc5.3.3org.mybatismybatis-spring2.0.6org.springframeworkspring-jdbc5.3.3compileorg.mybatismybatis3.5.2mysqlmysql-connector-java8.0.26junitjunit4.12te
  • Mybatis环境配置与测试 后端
    MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射。下面是配置MyBatis环境的详细步骤，并包含一个简单的测试示例。1.添加依赖首先，在Maven的pom.xml文件中添加MyBatis和数据库连接驱动的依赖。以MySQL为例：org.mybatismybatis3.5.6mysqlmysql-connector-java8.0.222.数据库配置在实际应用中，通常会
  • Mybatis-Mybatis介绍以及mybatis-config.xml配置 Rizzo_yuan MybatisMybatis介绍Mybatis动态代理
    一、什么是Mybatismybatis：是一种简化和实现了java数据化持久层（persistencelayer）的开源框架，它抽象了大量的JDBC冗余代码，并提供了一个简单的API和数据交互方式。mybatis的背景：MyBatis的前身是iBATIS，iBATIS于2002年由ClintonBegin创建。MyBatis3是iBATIS的全新设计，支持注解和Mapper(映射器)。MyBati
  • 【mybatis自动治愈插件】 小吴小吴bug全无 mybatis数据库javaLazyORM
    wu-database-lazy-mybatis-cure-plus-starter描述针对saas数据库隔离情况下，每次版本迭代都需要重新修改对应的数据库，对于升级与运维存在一定的难度，那么这个数据库治愈框架来了，使用场景如下1.数据库不存在自动创建数据库2.运行时表不存在自动创建表3.运行时字段不存在自动根据策略完善表字段模块版本描述mybatis3.5.4mybatis-plus-boot-
  • 后端的技术设计文档 乐之者v A1-系统设计与架构java
    一、背景1.简介2.业务规划(非必需)3.工作项拆解拆解成多个工作项，每个工作项，需要多少人力。4.资源评估(非必需)有没有新的服务二、架构设计1.架构图(非必需，新服务比较需要)2.技术选型SpringCloud、Redis、Mysql、Mybatis3.幂等设计(非必需)4.数据迁移方案(历史数据的处理)业务涉及数据迁移，数据批量变更等场景需要填写此项。5.性能评估(非必需)对于并发量和数据量
  • MySQL环境下，mybatis使用Cursor liangbo7 mysqlmybatisjava
    目录环境使用方式使用说明环境jdk8mybatis3.5.2mysql-connector-java8.0.22使用方式mapper:selectmenu_idasmenuId,menu_namemenuNamefromt_menuwheremenu_id<#{menuId}packagecom.demo.mapper;importcom.demo.entity.Menu;importorg
  • mybatis基础知识 远不及你的微笑 javamybatis
    title:mybatis的基础知识创建mybatis数据库，创建user表，在里面添加数据创建空项目，创建maven模块导入相关的依赖在pom.xml文件中导入mysql，junit测试，mybatis依赖。mysqlmysql-connector-java8.0.30org.mybatismybatis3.5.10junitjunit4.13.2test编写mybatis核心配置文件resou
  • Kotlin-集成SpringBoot+MyBatis+代码生成器 W_Meng_H Kotlinspringbootmybatiskotlin
    目录一、相关版本二、Maven因引入相关依赖三、SpringBoot配置文件四、代码生成工具五、实现用户服务模块案例1、Controller2、Service3、Entity4、Mapper5、接口测试一、相关版本工具版本Idea2022.3.2Springboot2.7.12Kotlin1.8.20MyBatis3.5.3.1MySQL8.0.28JDK1.8相关代码已分享到Gitee：http
  • Spring-mybatis 两仪式quq springmybatis
    怎样通过Spring整合Mybatis来实现业务目录1.导入依赖junitjunit3.8.1testmysqlmysql-connector-java8.0.33org.mybatismybatis3.5.13org.springframeworkspring-webmvc6.0.13org.springframeworkspring-jdbc6.0.13org.aspectjaspectjwe
  • Mybatis学习笔记 保护壳 后端javamybatis
    MyBatis一、简介1.1什么是MybatisMyBatis是一款优秀的持久层框架MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。MyBatis可以通过简单的XML或注解来配置和映射原始类型、接口和JavaPOJO（PlainOldJavaObjects，普通老式Java对象）为数据库中的记录如何获得Mybatis?maven仓库org.mybatismybatis3.
  • MyBatis框架-注解开发 陆卿之 mybatismybatis
    使用注解开发Mybatis详细的执行流程利用注解开发了解即可，实现开发中，不常用。mybatis最初配置信息是基于XML,映射语句(SQL)也是定义在XML中的。而到MyBatis3提供了新的基于注解的配置。不幸的是，Java注解的的表达力和灵活性十分有限。最强大的MyBatis映射并不能用注解来构建设置事务自动提交MyBatisUtil.java//获取SqlSession连接publicsta
  • 学习Spring的第十二天 y3131954546 spring学习java
    Bean基本注解开发创建一个空Maven项目:创建完如下之后在pom文件配置坐标org.springframeworkspring-context5.3.7com.alibabadruid1.1.23mysqlmysql-connector-java5.1.49org.mybatismybatis3.5.5org.springframeworkspring-jdbc5.2.13.RELEASEor
  • #千锋逆战# Mybatis多表联合 不是潘西是潘安
    Mybatis多表联合查找加入依赖加入mybatis核心依赖,junit测试,mysql依赖junitjunit4.12mysqlmysql-connector-java5.1.47org.mybatismybatis3.4.6XML配置resources目录下新建Mybatis.xml文件导入db.properties资源文件,如下driver=com.mysql.jdbc.Driverurl=
  • 毕业设计基于springboot+mybatis+mysql+layui实现的动漫论坛系统源码+数据库 程序员柳 数据库课程设计springboot
    介绍动漫论坛系统，系统架构：springboot+mybatis+mysql+layui系统截图技术选型技术版本说明SpringBoot2.1.6MVC核心框架SpringSecurityoauth22.1.5认证和授权框架MyBatis3.5.0ORM框架MyBatisPlus3.1.0基于mybatis，使用lambda表达式的Swagger-UI2.9.2文档生产工具Hibernator-V
  • 学生信息管理系统微信小程序源码+数据库，后台：springboot+mysql+mybatis+layui，前台：微信小程序 程序员柳 数据库微信小程序springboot
    StudentInfo-backend-master介绍学生信息微信小程序，分为两个项目，后台项目架构：springboot+mysql+mybatis+layui，前台架构：微信小程序软件架构软件架构说明技术选型技术版本说明SpringBoot2.1.6MVC核心框架SpringSecurityoauth22.1.5认证和授权框架MyBatis3.5.0ORM框架MyBatisPlus3.1.0
  • Java实现的基于模板的网页结构化信息精准抽取组件：HtmlExtractor yangshangchuan 信息抽取HtmlExtractor精准抽取信息采集
    HtmlExtractor是一个Java实现的基于模板的网页结构化信息精准抽取组件，本身并不包含爬虫功能，但可被爬虫或其他程序调用以便更精准地对网页结构化信息进行抽取。   HtmlExtractor是为大规模分布式环境设计的，采用主从架构，主节点负责维护抽取规则，从节点向主节点请求抽取规则，当抽取规则发生变化，主节点主动通知从节点，从而能实现抽取规则变化之后的实时动态生效。 如
  • java编程思想 -- 多态 百合不是茶 java多态详解
    一: 向上转型和向下转型 面向对象中的转型只会发生在有继承关系的子类和父类中（接口的实现也包括在这里）。父类：人    子类：男人向上转型： Person p = new Man() ; //向上转型不需要强制类型转化向下转型： Man man =
  • [自动数据处理]稳扎稳打,逐步形成自有ADP系统体系 comsci dp
          对于国内的IT行业来讲,虽然我们已经有了"两弹一星",在局部领域形成了自己独有的技术特征,并初步摆脱了国外的控制...但是前面的路还很长....       首先是我们的自动数据处理系统还无法处理很多高级工程...中等规模的拓扑分析系统也没有完成,更加复杂的
  • storm 自定义 日志文件 商人shang stormclusterlogback
    Storm中的日志级级别默认为INFO，并且，日志文件是根据worker号来进行区分的，这样，同一个log文件中的信息不一定是一个业务的，这样就会有以下两个需求出现： 1. 想要进行一些调试信息的输出 2. 调试信息或者业务日志信息想要输出到一些固定的文件中   不要怕，不要烦恼，其实Storm已经提供了这样的支持，可以通过自定义logback 下的 cluster.xml 来输
  • Extjs3 SpringMVC使用 @RequestBody 标签问题记录 21jhf
    springMVC使用 @RequestBody(required = false) UserVO userInfo 传递json对象数据，往往会出现http 415，400,500等错误，总结一下需要使用ajax提交json数据才行，ajax提交使用proxy，参数为jsonData，不能为params；另外，需要设置Content-type属性为json，代码如下： （由于使用了父类aaa
  • 一些排错方法 文强chu 方法
    1、java.lang.IllegalStateException: Class invariant violation at org.apache.log4j.LogManager.getLoggerRepository(LogManager.java:199)at org.apache.log4j.LogManager.getLogger(LogManager.java:228) at o
  • Swing中文件恢复我觉得很难 小桔子 swing
           我那个草了！老大怎么回事，怎么做项目评估的？只会说相信你可以做的，试一下，有的是时间！        用java开发一个图文处理工具，类似word，任意位置插入、拖动、删除图片以及文本等。文本框、流程图等，数据保存数据库，其余可保存pdf格式。ok,姐姐千辛万苦，
  • php 文件操作 aichenglong PHP读取文件写入文件
    1 写入文件 @$fp=fopen("$DOCUMENT_ROOT/order.txt", "ab"); if(!$fp){ echo "open file error" ; exit; } $outputstring="date:"." \t tire:".$tire."
  • MySQL的btree索引和hash索引的区别 AILIKES 数据结构mysql算法
    Hash 索引结构的特殊性，其 检索效率非常高，索引的检索可以一次定位，不像B-Tree 索引需要从根节点到枝节点，最后才能访问到页节点这样多次的IO访问，所以 Hash 索引的查询效率要远高于 B-Tree 索引。     可能很多人又有疑问了，既然 Hash 索引的效率要比 B-Tree 高很多，为什么大家不都用 Hash 索引而还要使用 B-Tree 索引呢
  • JAVA的抽象--- 接口 --实现 百合不是茶
    抽象 接口 实现接口   //抽象 类 ,方法   //定义一个公共抽象的类 ,并在类中定义一个抽象的方法体 抽象的定义使用abstract   abstract class A 定义一个抽象类 例如： //定义一个基类 public abstract class A{     //抽象类不能用来实例化，只能用来继承 //
  • JS变量作用域实例 bijian1013 作用域
    <script> var scope='hello'; function a(){ console.log(scope); //undefined var scope='world'; console.log(scope); //world console.log(b);
  • TDD实践（二） bijian1013 javaTDD
    实践题目：分解质因数 Step1： 单元测试： package com.bijian.study.factor.test; import java.util.Arrays; import junit.framework.Assert; import org.junit.Before; import org.junit.Test; import com.bijian.
  • [MongoDB学习笔记一]MongoDB主从复制 bit1129 mongodb
    MongoDB称为分布式数据库，主要原因是1.基于副本集的数据备份， 2.基于切片的数据扩容。副本集解决数据的读写性能问题，切片解决了MongoDB的数据扩容问题。   事实上，MongoDB提供了主从复制和副本复制两种备份方式，在MongoDB的主从复制和副本复制集群环境中，只有一台作为主服务器，另外一台或者多台服务器作为从服务器。 本文介绍MongoDB的主从复制模式，需要指明
  • 【HBase五】Java API操作HBase bit1129 hbase
    import java.io.IOException; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HBaseConfiguration; import org.apache.hadoop.hbase.HColumnDescriptor; import org.apache.ha
  • python调用zabbix api接口实时展示数据 ronin47
    zabbix api接口来进行展示。经过思考之后，计划获取如下内容：     1、  获得认证密钥     2、  获取zabbix所有的主机组     3、  获取单个组下的所有主机     4、  获取某个主机下的所有监控项  
  • jsp取得绝对路径 byalias 绝对路径
    在JavaWeb开发中，常使用绝对路径的方式来引入JavaScript和CSS文件，这样可以避免因为目录变动导致引入文件找不到的情况，常用的做法如下： 一、使用${pageContext.request.contextPath} 　　代码” ${pageContext.request.contextPath}”的作用是取出部署的应用程序名，这样不管如何部署，所用路径都是正确的。
  • Java定时任务调度：用ExecutorService取代Timer bylijinnan java
    《Java并发编程实战》一书提到的用ExecutorService取代Java Timer有几个理由，我认为其中最重要的理由是： 如果TimerTask抛出未检查的异常，Timer将会产生无法预料的行为。Timer线程并不捕获异常，所以 TimerTask抛出的未检查的异常会终止timer线程。这种情况下，Timer也不会再重新恢复线程的执行了;它错误的认为整个Timer都被取消了。此时，已经被
  • SQL 优化原则 chicony sql
    一、问题的提出 　在应用系统开发初期，由于开发数据库数据比较少，对于查询SQL语句，复杂视图的的编写等体会不出SQL语句各种写法的性能优劣，但是如果将应用系统提交实际应用后，随着数据库中数据的增加，系统的响应速度就成为目前系统需要解决的最主要的问题之一。系统优化中一个很重要的方面就是SQL语句的优化。对于海量数据，劣质SQL语句和优质SQL语句之间的速度差别可以达到上百倍，可见对于一个系统
  • java 线程弹球小游戏 CrazyMizzz java游戏
    最近java学到线程，于是做了一个线程弹球的小游戏，不过还没完善 这里是提纲 1.线程弹球游戏实现 1.实现界面需要使用哪些API类 JFrame JPanel JButton FlowLayout Graphics2D Thread Color ActionListener ActionEvent MouseListener Mouse
  • hadoop jps出现process information unavailable提示解决办法 daizj hadoopjps
    hadoop jps出现process information unavailable提示解决办法   jps时出现如下信息： 3019 -- process information unavailable3053 -- process information unavailable2985 -- process information unavailable2917 --
  • PHP图片水印缩放类实现 dcj3sjt126com PHP
    <?php class Image{ private $path; function __construct($path='./'){ $this->path=rtrim($path,'/').'/'; } //水印函数，参数：背景图，水印图，位置，前缀,TMD透明度 public function water($b,$l,$pos
  • IOS控件学习：UILabel常用属性与用法 dcj3sjt126com iosUILabel
    参考网站： http://shijue.me/show_text/521c396a8ddf876566000007 http://www.tuicool.com/articles/zquENb http://blog.csdn.net/a451493485/article/details/9454695 http://wiki.eoe.cn/page/iOS_pptl_artile_281
  • 完全手动建立maven骨架 eksliang javaeclipseWeb
    建一个 JAVA 项目 ： mvn archetype:create -DgroupId=com.demo -DartifactId=App [-Dversion=0.0.1-SNAPSHOT] [-Dpackaging=jar] 建一个 web 项目 ： mvn archetype:create -DgroupId=com.demo -DartifactId=web-a
  • 配置清单 gengzg 配置
    1、修改grub启动的内核版本 vi /boot/grub/grub.conf 将default 0改为1 拷贝mt7601Usta.ko到/lib文件夹 拷贝RT2870STA.dat到 /etc/Wireless/RT2870STA/文件夹 拷贝wifiscan到bin文件夹，chmod 775 /bin/wifiscan 拷贝wifiget.sh到bin文件夹，chm
  • Windows端口被占用处理方法 huqiji windows
    以下文章主要以80端口号为例，如果想知道其他的端口号也可以使用该方法..........................1、在windows下如何查看80端口占用情况?是被哪个进程占用?如何终止等.        这里主要是用到windows下的DOS工具,点击"开始"--"运行",输入&
  • 开源ckplayer 网页播放器， 跨平台(html5, mobile)，flv, f4v, mp4, rtmp协议. webm, ogg, m3u8 ！ 天梯梦 mobile
    CKplayer，其全称为超酷flv播放器，它是一款用于网页上播放视频的软件，支持的格式有：http协议上的flv,f4v,mp4格式，同时支持rtmp视频流格 式播放，此播放器的特点在于用户可以自己定义播放器的风格，诸如播放/暂停按钮，静音按钮，全屏按钮都是以外部图片接口形式调用，用户根据自己的需要制作 出播放器风格所需要使用的各个按钮图片然后替换掉原始风格里相应的图片就可以制作出自己的风格了，
  • 简单工厂设计模式 hm4123660 java工厂设计模式简单工厂模式
           简单工厂模式（Simple Factory Pattern）属于类的创新型模式，又叫静态工厂方法模式。是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。
  • maven笔记 zhb8015 maven
    跳过测试阶段： mvn package -DskipTests 临时性跳过测试代码的编译： mvn package -Dmaven.test.skip=true   maven.test.skip同时控制maven-compiler-plugin和maven-surefire-plugin两个插件的行为，即跳过编译，又跳过测试。   指定测试类 mvn test
  • 非mapreduce生成Hfile，然后导入hbase当中 Stark_Summer maphbasereduceHfilepath实例
    最近一个群友的boss让研究hbase，让hbase的入库速度达到5w+/s，这可愁死了，4台个人电脑组成的集群，多线程入库调了好久，速度也才1w左右，都没有达到理想的那种速度，然后就想到了这种方式，但是网上多是用mapreduce来实现入库，而现在的需求是实时入库，不生成文件了，所以就只能自己用代码实现了，但是网上查了很多资料都没有查到，最后在一个网友的指引下，看了源码，最后找到了生成Hfile
  • jsp web tomcat 编码问题 王新春 tomcatjsppageEncode
    今天配置jsp项目在tomcat上，windows上正常，而linux上显示乱码，最后定位原因为tomcat 的server.xml 文件的配置，添加 URIEncoding 属性： <Connector port="8080" protocol="HTTP/1.1" connectionTi
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他