JDBC#

1
//定义了UserDao接口，我们传入id，可以查询user的记录出来
2
public interface UserDao {
3
    User selectByPrimaryKey(Integer id) throws Exception;
4
}
5
// 假如我们定义了实现类，那么我们可以这样子来调用获得user记录
6
public class JdbcExecution {
7
    // 查询id为2的用户
8
    public static void main(String[] args) throws Exception{
9
        UserDao userDao = new UserDaoImpl();
10
        User user = userDao.selectByPrimaryKey(2);
11
        System.out.println("user = " + user);
12
    }
13
}

接着问题就是我们在实现类中的代码，使用JDBC的方式来完成，我们也把过程中的一些操作做一些分析，可以参考注释

1
public class UserDaoImpl implements UserDao{
2
    @Override
3
    public User selectByPrimaryKey(Integer id) throws Exception {
4
        // 1.获得连接，如果后面需要提交事务，则执行connection.commit
5
        Connection connection = JdbcUtil.getConnection();
6
        // 2.预编译，预编译过程中传入了SQL语句
7
        PreparedStatement preparedStatement = connection.prepareStatement("select id, username, password, age, birthday, create_date, mobile from cskaoyan_user where id = ?");
8
        // 3.提供占位符位置的值
9
        preparedStatement.setInt(1,id);
10
        // 4.执行查询获得结果集
11
        ResultSet resultSet = preparedStatement.executeQuery();
12
        // 5.创建一个接收结果集中的值的实例
13
        User user = new User();
14
        while (resultSet.next()) {
15
            // 6.获得结果集中的username列(column)中的值
16
            String username = resultSet.getString("username");
17
            //   获得结果集中的password列(column)中的值
18
            String password = resultSet.getString("password");
19
            int age = resultSet.getInt("age");
20
            Date birthday = resultSet.getDate("birthday");
21
            Date createDate = resultSet.getDate("create_date");
22
            String mobile = resultSet.getString("mobile");
23
            user.setId(id);
24
            // 7.通过set方法封装给user实例中的username这个成员变量(property)
25
            user.setUsername(username);
26
            //   通过set方法封装给user实例中的password这个成员变量(property)
27
            user.setPassword(password);
28
            user.setAge(age);
29
            user.setBirthday(birthday);
30
            user.setCreateDate(createDate);
31
            user.setMobile(mobile);
32
        }
33
        return user;
34
    }
35
}

这个过程比较繁琐，并且存在着很多定制化的内容和耦合

• SQL语句和代码直接耦合在一起
• 设置参数过程比较繁琐，对应的关系只有占位符的序号，如果有多个占位符？的话，容易出错
• 查询结果集的使用比较繁琐
  • 手动调用构造方法来获得实例
  • 要关注列名从结果集中取出数据
  • 要关注列的类型手动调用不同的方法，比如getInt、getString、getDate
  • 取出的值需要使用set方法来封装

MyBatis#

导包

1
<!--mybatis-->
2
<dependency>
3
       <groupId>org.mybatis</groupId>
4
       <artifactId>mybatis</artifactId>
5
       <version>3.5.9</version>
6
</dependency>
7
<!-- 数据库驱动包 -->
8
<dependency>
9
    <groupId>mysql</groupId>
10
    <artifactId>mysql-connector-java</artifactId>
11
       <version>8.0.20</version>
12
   </dependency>

配置1: 配置一个Mybatis的主配置文件，用来获取SqlSessionFactory

1
// SqlSessionFactory：每一个Mybatis应用都是以SqlSessionFactory的实例对象为核心的。使用Mybatis必须以SqlSessionFactory的实例为核心，再以SqlSessionFactory的实例生产SqlSession实例对象的。
2
// SqlSession：这个其实表示和数据库之间的一个连接，里面封装了 Connection对象

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="jdbc.properties"/>
7
   <!--日志的配置-->
8
   <settings>
9
       <setting name="logImpl" value="STDOUT_LOGGING"/>
10
   </settings>
11
       <environments default="development">
12
           <environment id="development">
13
                <transactionManager type="JDBC"/>
14
                <dataSource type="POOLED">
15
                    <property name="driver" value="com.mysql.jdbc.Driver"/>
16
                    <property name="url"
17
                              value="${url}"/>
18
                    <property name="username" value="${username}"/>
19
                    <property name="password" value="${password}"/>
20
                </dataSource>
21
            </environment>
22
       </environments>
23
   <mappers>
24
       <mapper resource="com/cskaoyan/mapper/UserMapper.xml"/>
25
       </mappers>
26
    </configuration>

展开收起

配置2: 配置一个专门用来存放SQL语句的配置文件，Mapper.xml

1
// 在Mybatis中，这样的文件可以有多个
2
// 这些文件，都必须在Mybatis的主配置文件中，声明进来、

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
<!-- namespace: 命名空间，整个项目中必须唯一，暂时可以任意取名(后面再进行标准化) -->
6
<mapper namespace="usersql">
7
   <!-- 每个标签都需要一个唯一的id属性:
8
 每一个标签的id不能重复(本Mapper文件中), 用来标识一条SQL  -->
9
       <!-- 在这个Mapper文件中, 怎么唯一表示SQL语句?
10
       namespace.id (命名空间.标签的id ) 是这个SQL语句的坐标  -->
11
   <!-- <insert> 插入标签 -->
12
       <!-- <delete> 删除标签 -->
13
        <!-- <update> 修改标签 -->
14
       <!-- <select> 查询标签 -->
15

16
       <!-- parameterType：参数的类型(可以省略,标准语法要指明 ) -->
17
       <!-- resultType：返回的结果集的类型(不能省略) -->
18
   <select id="selectByPrimaryKey" resultType="com.cskaoyan.model.User">
19
           select id, username, password, age, birthday, create_date as createDate, mobile from cskaoyan_user where id = #{id}
20
       </select>
21

22
    </mapper>

展开收起

使用

1
//使用的代码和前面完全一样
2
public class MyBatisExecution {
3

4
   // 查询id为2的用户
5
   public static void main(String[] args) throws Exception{
6
       UserDao userDao = new UserDaoImpl();
7
       User user = userDao.selectByPrimaryKey(2);
8
       System.out.println("user = " + user);
9
   }
10
}

但是UserDaoImpl中的实现则完全不一样了

1
public class UserDaoImpl implements UserDao{
2
   @Override
3
   public User selectByPrimaryKey(Integer id) {
4
       // 1.获得全局共享的SqlSessionFactory(线程安全)
5
       SqlSessionFactory sqlSessionFactory = MyBatisUtil.getSqlSessionFactory();
6
       // 2.开启SqlSession(线程不安全)，其中封装了Connection
7
       SqlSession sqlSession = sqlSessionFactory.openSession();
8
       // 3.(1)传入Sql的坐标;(2)传入参数;(3)查询结果集的封装
9
       User user = sqlSession.selectOne("usersql.selectByPrimaryKey", id);
10
       return user;
11
   }
12
}

其中MyBatisUtil是提供全局共享的SqlSessionFactory实例的

1
public class MyBatisUtil {
2
     // 线程安全的值，可以全局共享
3
     private static SqlSessionFactory sqlSessionFactory;
4
     static {
5
        try {
6
          sqlSessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis.xml"));
7
        } catch (IOException e) {
8
          e.printStackTrace();
9
        }
10
     }
11

12
     public static SqlSessionFactory getSqlSessionFactory() {
13
        return sqlSessionFactory;
14
     }
15
}

展开收起

分析#

在上面的案例中MyBatis默默的替我们做了什么事情

• connection.preparedStatement需要传入的Sql语句，我们仅仅提供了坐标（映射文件的命名空间+id）
• 参数和占位符的对应关系，自动对应起来
• resultSet获得结果集，并且封装为User实例的过程完全是MyBatis自动完成的

而上面的过程其实是实际开发过程中非常繁琐，而又很通用的事情

动态代理#

一些问题

1
// 目前Mybatis使用起来还不够灵活，不够简单。
2
// 虽然解决了SQL语句硬编码的问题，但是又出现了新的问题
3
SQL语句的坐标存在硬编码
4
sqlSession调用的方法需要我们自己去指定
5
//也就是UserDaoImpl中的内容还不够通用，我们想要进一步干掉它

而Mybatis的动态代理可以帮助我们去生成接口的代理对象。我们可以自己不实现接口。

1
// 不需要实现接口，那么就需要遵守Mybatis使用动态代理的一些规则
2
1, 接口的全限定名称 和 mapper.xml中的namespace的值保持一致
3
2, 接口中的方法和 xml文件中的 <select> <insert> <update> <delete> 标签 一一对应，并且方法名要和标签的id值保持一致
4
3, 方法的返回值类型和标签中的resultType保持一致(注意:添加/删除/修改不需要返回值类型)
5
4, 参数保持一致(暂时可以不写)
6

7
// 建议要遵守的规则：希望
8
  1, 文件的名字 UserMapper.xml  | UserMapper.java 建议保持一致
9
  2, UserMapper.xml 和UserMapper.java 在编译之后的位置应该要在同一个路径下

编译后在同一路径

如何使用动态代理呢？

1
public class MyBatisExecution {
2

3
    // 查询id为2的用户
4
    public static void main(String[] args) throws Exception{
5
        //UserDao userDao = new UserDaoImpl();
6
        // 1.获取SqlSession
7
        SqlSession sqlSession = MyBatisUtil.getSqlSessionFactory().openSession();
8
        // 2.根据SqlSession获得Mapper代理对象
9
        UserMapper userDao = sqlSession.getMapper(UserMapper.class);
10
        // 3.代理对象执行方法
11
        User user = userDao.selectByPrimaryKey(2);
12
        System.out.println("user = " + user);
13
    }
14
}

思考：代理对象做增强，他做了什么增强？

增删改查示例#

添加

1
Account account = new Account();
2
account.setId(10);
3
account.setName("李白");
4
account.setMoney(200);
5
int rows  = accountMapper.insertAccount(account);
6

7
// sqlSession.commit();
8
Connection connection = sqlSession.getConnection();
9
connection.commit();

1
// 添加
2
public int insertAccount(Account account);

1
<!--public int insertAccount(Account account);-->
2
<insert id="insertAccount" >
3
       insert into account set id=#{id}, name=#{name}, money=#{money}
4
</insert>

删除

1
int rows  = accountMapper.deleteAccountById(10);
2
// sqlSession.commit();
3
Connection connection = sqlSession.getConnection();
4
connection.commit();

1
// 删除
2
public int deleteAccountById(Integer id);

1
<delete id="deleteAccountById">
2
       delete from account where id=#{id}
3
</delete>

修改

1
Account account = new Account();
2
account.setId(10);
3
account.setName("zs");
4
account.setMoney(2000);
5
int rows  = accountMapper.updateAccountById(account);
6

7
// sqlSession.commit();
8
Connection connection = sqlSession.getConnection();
9
connection.commit();

1
// 修改
2
public int updateAccountById(Account account);

1
<update id="updateAccountById">
2
       update account set name=#{name}, money=#{money} where id =#{id}
3
</update>

查找

1
Account account = accountMapper.selectAccountById(10);
2
System.out.println(account);

1
// 查找
2
public Account selectAccountById(Integer id);

1
<select id="selectAccountById"  parameterType="java.lang.Integer" resultType="com.snow.www.bean.Account">
2
   select * from account where id = #{id}
3
</select>

事务#

在使用Mybatis的时候, 自带事务，而且事务默认情况下是不会自动提交的

1
// 解决办法一:  执行完SQL语句之后, 使用sqlSession提交事务
2
sqlSession.commit();
3
// 解决办法二:  执行完SQL语句之后, 使用sqlSession内部封装的Connection 提交事务
4
   Connection conn  = sqlSession.getConnection();
5
   conn.commit();
6
// 解决办法三:(自动提交) 在获得SqlSession的时候, 给sqlSessionFactory.openSession设置为真
7
   // 获取到的SqlSession，里面的connection不会自动提交
8
   SqlSession session = sqlSessionFactory.openSession();
9
   // 获取自动提交的SqlSession
10
   SqlSession session = sqlSessionFactory.openSession(true);

properties#

properties表示可以外部配置的属性，并可以进行动态替换。(作为典型的是JDBC配置)

1
driver=com.mysql.jdbc.Driver
2
url=jdbc:mysql://localhost:3306/db47?useSSL=false&userUnicode=true&characterEncoding=utf8
3
username=root
4
password=123456

1
<configuration>
2
   <!-- 引入外部配置文件 -->
3
   <properties resource="jdbc.properties" ></properties>
4
</configuration>

settings#

settings是MyBatis的行为配置(类似于idea和settings的关系)

eg: 日志配置

1
<configuration>
2
   <settings>
3
       <!--  添加日志的配置 -->
4
       <setting name="logImpl" value="STDOUT_LOGGING"/>
5
  </settings>
6
</configuration>

一个完整的settings配置 (暂时没用)

1
<settings>
2
 <setting name="cacheEnabled" value="true"/>
3
 <setting name="lazyLoadingEnabled" value="true"/>
4
 <setting name="aggressiveLazyLoading" value="true"/>
5
 <setting name="multipleResultSetsEnabled" value="true"/>
6
 <setting name="useColumnLabel" value="true"/>
7
 <setting name="useGeneratedKeys" value="false"/>
8
 <setting name="autoMappingBehavior" value="PARTIAL"/>
9
 <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
10
 <setting name="defaultExecutorType" value="SIMPLE"/>
11
 <setting name="defaultStatementTimeout" value="25"/>
12
 <setting name="defaultFetchSize" value="100"/>
13
 <setting name="safeRowBoundsEnabled" value="false"/>
14
 <setting name="safeResultHandlerEnabled" value="true"/>
15
 <setting name="mapUnderscoreToCamelCase" value="false"/>
16
 <setting name="localCacheScope" value="SESSION"/>
17
 <setting name="jdbcTypeForNull" value="OTHER"/>
18
 <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
19
 <setting name="defaultScriptingLanguage" value="org.apache.ibatis.scripting.xmltags.XMLLanguageDriver"/>
20
 <setting name="defaultEnumTypeHandler" value="org.apache.ibatis.type.EnumTypeHandler"/>
21
 <setting name="callSettersOnNulls" value="false"/>
22
 <setting name="returnInstanceForEmptyRow" value="false"/>
23
 <setting name="logPrefix" value="exampleLogPreFix_"/>
24
 <setting name="logImpl" value="SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING"/>
25
 <setting name="proxyFactory" value="CGLIB | JAVASSIST"/>
26
 <setting name="vfsImpl" value="org.mybatis.example.YourselfVfsImpl"/>
27
 <setting name="useActualParamName" value="true"/>
28
 <setting name="configurationFactory" value="org.mybatis.example.ConfigurationFactory"/>
29
</settings>

展开收起

typeAliases#

typeAlies类型别名。(也就是我们可以对 类 起别名，简化操作) (暂时不建议使用)

1
<configuration>
2

3
    <!-- 类型别名 -->
4
    <typeAliases>
5
        <!-- alias别名 type全限定名 -->
6
        <typeAlias alias="account" type="com.snow.www.bean.Account"/>
7
        <typeAlias alias="user" type="com.snow.www.bean.User"/>
8
    </typeAliases>
9
</configuration>

1
<select id="selectAccountById"  resultType="account">
2
    select * from account where id = #{id}
3
</select>

注意: Mybatis对于一些基本类型和包装类型，以及集合类型，有内置的别名。

1
// 值得注意的是下面是一些为常见的 Java 类型内建的类型别名。它们都是不区分大小写的，而且为了应对原始类型的命名重复，采取了特殊的命名风格。
2
// 注意: 除了内置别名,  不要乱起别名

1
 <select id="selectNameById"
2
            parameterType="java.lang.Integer"
3
            resultType="java.lang.String">
4
        select name from account where id = #{id}
5
</select>
6
<select id="selectNameById"
7
        parameterType="Integer"
8
        resultType="String">
9
    select name from account where id = #{id}
10
</select>
11
<select id="selectNameById"
12
        parameterType="integer"
13
        resultType="string">
14
    select name from account where id = #{id}
15
</select>
16
<select id="selectNameById"
17
            parameterType="_int"
18
            resultType="String">
19
     select name from account where id = #{id}
20
</select>

展开收起

别名	映射的类型
_byte	byte
_long	long
_short	short
_int	int
_integer	int
_double	double
_float	float
_boolean	boolean
string	String
byte	Byte
long	Long
short	Short
int	Integer
integer	Integer
double	Double
float	Float
boolean	Boolean
date	Date
decimal	BigDecimal
bigdecimal	BigDecimal
object	Object
map	Map
hashmap	HashMap
list	List
arraylist	ArrayList
collection	Collection
iterator	Iterator

注意:

1, typeHandlers: MyBatis 对我们SQL参数或从结果集中取出一个值时， 都会用类型处理器将获取到的值以合适的方式转换成 Java 类型。(而在我们使用的时候是无法感知这个问题的, 属于MyBatis的底层处理).

2, ObjectFactory: MyBatis 使用一个对象工厂实例来完成实例化工作。 默认的对象工厂要么通过默认无参构造方法，要么通过有参数的构造方法实例化对象。如果想覆盖对象工厂的默认行为，可以通过创建自己的对象工厂来实现。(不要使用)

environments#

environments: 可以配置成适应多种环境.比如开发环境、测试环境和生产环境等可能需要有不同的配置.

1
<!-- 环境的配置，其实就是去配置数据库连接-->
2
<environments default="development">
3

4
   <!-- 环境的id，是唯一的-->
5
   <environment id="development">
6

7
       <!-- 事务管理器
8
           JDBC:   使用JDBC连接来管理事务
9
           MANAGED: 把事务的管理交给外部的容器 -->
10
       <!-- 如果你正在使用 Spring + MyBatis，则没有必要配置事务管理器，
11
        因为 Spring 模块会使用自带的管理器来覆盖前面的配置。-->
12
       <transactionManager type="JDBC"/>
13

14
       <!--
15
           POOLED： 使用Mybatis自带的连接池
16
           UNPOOLED：不使用连接池
17
           JNDI：使用外部的连接池  -->
18
       <dataSource type="POOLED">
19
           <property name="driver" value="${driver}"/>
20
           <property name="url" value="${url}"/>
21
           <property name="username" value="${username}"/>
22
           <property name="password" value="${password}"/>
23
       </dataSource>
24
   </environment>
25

26
   <environment id="test">
27
       <transactionManager type="JDBC"/>
28
       <dataSource type="POOLED">
29
           <property name="driver" value="${driver}"/>
30
           <property name="url" value="${url}"/>
31
           <property name="username" value="${username}"/>
32
           <property name="password" value="${password}"/>
33
       </dataSource>
34
   </environment>
35

36
   <environment id="prod">
37
       <transactionManager type="JDBC"/>
38
       <dataSource type="POOLED">
39
           <property name="driver" value="${driver}"/>
40
           <property name="url" value="${url}"/>
41
           <property name="username" value="${username}"/>
42
           <property name="password" value="${password}"/>
43
       </dataSource>
44
   </environment>
45
</environments>

展开收起

mappers#

这个是映射器的配置。配置mapper.xml配置文件。

配置方式一: 直接以对应mapper文件的相对路径

1
<configuration>
2
 <mappers>
3
        <mapper resource="com/snow/www/mapper/AccountMapper.xml"/>
4
        <mapper resource="com/snow/www/mapper/User.xml"/>
5
    </mappers>
6
</configuration>

配置方式二: 配置某个包下的所有的配置文件

1
<configuration>
2
  <!--
3
        1. 接口和映射文件编译后要在同一级目录，并且同名
4
        2. 接口的全限定类名作为映射文件的命名空间
5
        3. 接口中的方法名（方法不允许重载）作为映射文件中的标签id（不允许重复）
6
    -->
7
  <mappers>
8
        <package name="com.snow.www.mapper"/>
9
    </mappers>
10
</configuration>

一个参数#

一个参数: (基本类型、包装类、String)

1, #{任意值} 来取值: 不建议使用(显得不标准), 建议使用注解写法

1
// 虽然一个参数的时候, 可以在{}内部任意书写参数名, 这种乱写行为不好, 不要这么写

1
// 查找
2
public Account selectAccountById(Integer id);

1
<select id="selectAccountById"  resultType="account">
2
     select * from account where id = #{xxx}
3
</select>

2, 如果在方法中 的一个参数 加了@Param注解，那么 后面就只能通过 #{注解值} 来取值

1
// 查找
2
public Account selectAccountById2(@Param("id") Integer id);

1
<select id="selectAccountById2"   resultType="acc">
2
     select * from account where id = #{id}
3
</select>

多个参数#

多个参数: 需要注解指明#{注解值} 来取值

1
// 1, 直接写多个值, 用参数名简单匹配是不识别的
2
// 2, 如果参数名简单匹配是不识别, 又不想加注解, 也是有别的解决手段(按位传值: 不建议), 但是建议加注解(最标准的写法)

1
// 查找
2
List<Account> selectListByIdOrName(@Param("id") Integer id,
3
                             @Param("name") String name);

1
<select id="selectListByIdOrName"   resultType="acc">
2
select * from account where id = #{id} or name = #{name}
3
</select>

对象传值#

对象传值

方式一: SQL使用的参数命名要和对象内部属性保持一致 (#{成员变量名} 来取值)

1
public interface UserMapper {
2
 //对象传值 → 没有使用@Param注解 → 成员变量名
3
 int insert1(User user);
4

5
}

1
<insert id="insert1">
2
 insert into cskaoyan_user (username, password, age, birthday, create_date, mobile) values
3
 (#{username},#{password},#{age},#{birthday},#{createDate},#{mobile})
4
</insert>

方式二: 对象有注解, 必须通过 #{注解值 . 成员变量名} 来取值

1
//对象传值 → 使用@Param注解 → @Param写了什么就用什么 → user.username、user.password等
2
int insert2(@Param("user") User user);

1
<insert id="insert2">
2
 insert into cskaoyan_user (username, password, age, birthday, create_date, mobile) values
3
 (#{user.username},#{user.password},#{user.age},#{user.birthday},#{user.createDate},#{user.mobile})
4
</insert>

注意: 对象和多参数混合问题

使用Map传值#

Map传值: 不建议使用

方式一: SQL使用的参数命名要和Map中存储数据的key保持一致 (#{key} 来取值)

1
//Map传值 → 没有使用@Param注解 → #{}里写的是map的key：id和username
2
    int updateUsernameById(Map map);

1
<update id="updateUsernameById">
2
     update cskaoyan_user set username = #{username} where id = #{id}
3
</update>

方式二: Map对象有注解, 必须通过 #{注解值 . key} 来取值

1
//Map传值 → 使用@Param注解 → #{}里写的是@Param注解的值 + map的key：map.id和map.username
2
int updateUsernameById2(@Param("map") Map map);

1
<update id="updateUsernameById2">
2
     update cskaoyan_user set username = #{map.username} where id = #{map.id}
3
</update>

按位置传值#

按位传值: 完全不建议(容易因为程序员的记忆和修改导致bug产生, 除非除了按位传值没办法了)

方式一: arg0、arg1、arg2…

1
userMapper.insertUser("zs", 18, "湖北");

1
<insert id="insertUser">
2
       insert into `user`  set `name`=#{arg0}, age=#{arg1}, address=#{arg2}
3
</insert>

方式二: param1、param2、param3…

1
userMapper.insertUser("zs", 18, "湖北");

1
<insert id="insertUser">
2
       insert into `user`  set `name`=#{param1}, age=#{param2}, address=#{param3}
3
</insert>

在Mybatis的输入映射中，我们经常使用前面三种方式（传入一个参数、传入多个参数、传递对象），后面通过map传值和按照位置来传值 一般不使用，也不建议大家使用。

#和$的区别#

${}做的就是字符串的拼接，如果你传入的是字符串，需要你手动在${}外围手动增加单引号 ”

核心点: 使用${}有sql注入的风险

SQL注入：在你执行的SQL语句之外额外执行一部分，导致信息泄露或数据库被丢弃；

使用#{}过程是预编译，不会有SQL注入的风险，建议大家使用的方式

#{参数}使用: 预编译占位 (尽量使用 #{} ) PreparedStatement

1
userMapper.insertUserC("zs", 18, "湖北");

1
<insert id="insertUserC">
2
       insert into `user`  set `name`=#{param1}, age=#{param2}, address=#{param3}
3
</insert>

${参数}使用: 字符串拼接, Statement (存在SQL注入问题)

1
userMapper.insertUserP("zs", 18, "湖北");

1
<insert id="insertUserP">
2
insert into `user`  set `name`= '${param1}', age=${param2}, address='${param3}'
3
</insert>

1
SELECT id,product,money FROM `cskaoyan_product` where id = 3;
2

3
-- 如果我们使用#{}的方式
4
-- Preparing：
5
SELECT id,product,money FROM `cskaoyan_product` where id = ？
6
-- Parameters：3
7

8
-- 如果我们使用${}的方式
9
-- id提供的值是3
10
-- Preparing：
11
SELECT id,product,money FROM `cskaoyan_product` where id = '3';
12
-- Parameters：
13

14
-- 如果有不法分子，提供的参数不是3，在3的基础上额外搞了一些东西
15
-- 3' or '1' = '1
16
SELECT id,product,money FROM `cskaoyan_product` where id = '3' or '1' = '1';

思考#

MyBatis在输入映射过程中有传入对象作为参数，那么这个过程是对JDBC做封装，思考一个问题就是JDBC过程会如何使用我们的对象的

比如这个接口和方法

1
public interface UserMapper {
2
    //对象传值 → 没有使用@Param注解 → 成员变量名
3
    int insert1(User user);
4
}

对JDBC过程在分解一下

1
Connection connection = ConnectionUtil.getConnection();
2
PreparedStatement preparedStatement = connection.preparedStatement("insert into cskaoyan_user (username, password, age, birthday, create_date, mobile) values (?,?,?,?,?,?)");
3
// 传入的是user对象
4
preparedStatement.setString(1,user.getUsername());
5
preparedStatement.setString(2,user.getPassword());
6
...

输入映射，MyBatis如何使用的user，通过get方法来使用的

一个参数#

结果列为1且记录数为1（或0）

一个参数: 必须要有resultType(写简单参数的全限定名称或者是内置的别名)

1
// 单个列，结果记录数为1
2
int selectCount();
3
String selectNameById(@Param("id") Integer id);//List<String> list → list.get(0)

1
<select id="selectCount" resultType="int">
2
 select count(*) from cskaoyan_user
3
</select>
4

5
   <select id="selectNameById" resultType="java.lang.String">
6
 select username from cskaoyan_user where id = #{id}
7
</select>

多个参数#

列只有一列，结果集中的记录数有多条（0或1条）

指: 多个参数构成的数组/List/Set

1
// 当我们返回多个简单参数的时候，在方法中定义的是数组就会返回数组，定义的是集合就会返回集合。xml中的标签配置不需要改变。并且, resultType的值是单个元素的类型。

1
// 单个列，结果记录数为多条
2
// 按照不同的类型来封装，但是SQL语句是一样的
3
String[] selectNamesByAge1(@Param("age") Integer age);
4
List<String> selectNamesByAge2(@Param("age") Integer age);
5
Set<String> selectNamesByAge3(@Param("age") Integer age);

1
<select id="selectNamesByAge1" resultType="java.lang.String">
2
  select username from cskaoyan_user where age = #{age}
3
</select>
4
<select id="selectNamesByAge2" resultType="java.lang.String">
5
  select username from cskaoyan_user where age = #{age}
6
</select>
7
<select id="selectNamesByAge3" resultType="java.lang.String">
8
  select username from cskaoyan_user where age = #{age}
9
</select>

单个对象#

核心点：查询结果集中的列名 要和 对象中的成员变量名（set方法）相同

查询结果集中的列名可以通过as起别名的方式做修改

单个对象:

1
// 1. Mybatis在去映射的时候，会把`成员变量名` 和`查询结果的列名`去一一映射，假如原始表中的列名和成员变量名不一致的话，我们可以通过取别名的方式来解决(也可以通过resultMap来解决)
2
// 2. 在声明JavaBean的成员变量的时候，尽量的使用包装类型

1
// 多个列，结果记录数为1
2
User selectByPrimaryKey(@Param("id") Integer id);

1
<select id="selectByPrimaryKey" resultType="com.cskaoyan.demo2.bean.User">
2
 select id, username, password, age, birthday, create_date as createDate, mobile from cskaoyan_user
3
 where id = #{id}
4
</select>
5
    ````

多个对象#

如果是采用JDBC会如何写

1
ResultSet resultSet = prepareStatement.executeQuery();
2
List<User> users = new ArrayList<>();
3
while(resultSet.next()){
4
  User user = new User();
5
  user.setUsername(resultSet.getString("username"));
6
  user.setPassword(resultSet.getString("password"));
7
  user.setAge(resultSet.getInt("age"));
8
  user.setBirthday(resultSet.getDate("birthday"));
9
  user.setCreateDate(resultSet.getDate("createDate"));
10
  user.setMobile(resultSet.getString("mobile"));
11
  users.add(user);
12
}
13
//如果你需要一个Set可以在第2行这里定义为一个set ，也可以将这个List转为一个Set
14
//如果你需要一个数组，也可以将这个List转为一个数组

多个对象: 数组/List/Set

1
//1,  resultType的值是单个元素的类型。

1
// 多个列，结果记录数为多条
2
User[] selectByAge1(@Param("age") Integer age);
3

4
List<User> selectByAge2(@Param("age") Integer age);
5

6
Set<User> selectByAge3(@Param("age") Integer age);

1
<select id="selectByAge1" resultType="com.cskaoyan.demo2.bean.User">
2
 select id, username, password, age, birthday, create_date as createDate, mobile from cskaoyan_user
3
 where age = #{age}
4
</select>
5
<select id="selectByAge2" resultType="com.cskaoyan.demo2.bean.User">
6
 select id, username, password, age, birthday, create_date as createDate, mobile from cskaoyan_user
7
 where age = #{age}
8
</select>
9
<select id="selectByAge3" resultType="com.cskaoyan.demo2.bean.User">
10
 select id, username, password, age, birthday, create_date as createDate, mobile from cskaoyan_user
11
 where age = #{age}
12
</select>

resultMap#

核心点：查询结果集中的列名 要和 对象中的成员变量名（set方法）对应

存在这样的对应关系，我们才知道从结果集拿那一列的值(resultSet.getString(“列名”))，获得的值要封装给哪一个成员变量

resultMap: 是用来做参数映射的

1
@Data
2
   public class UserVo {
3
     private Integer userId;
4
     private String userName;
5
     private Integer userAge;
6
 private String userMobile;
7
}

1
UserVo selectUserVoByPrimaryKey(@Param("id") Integer id);

1
<!--id属性：要和select标签中的resultMap属性建立联系-->
2
<!--type属性：写的是要封装的对象的全限定类名（或别名）-->
3
<resultMap id="userVoMap" type="com.cskaoyan.demo2.bean.UserVo">
4
 <!--查询结果集中的列名要和成员变量名建立映射关系-->
5
 <id column="id" property="userId"/>
6
 <result column="age" property="userAge"/>
7
 <result column="username" property="userName"/>
8
 <result column="mobile" property="userMobile"/>
9
</resultMap>
10
<!--resultMap属性中写的是引用的resultMap标签的id-->
11
<select id="selectUserVoByPrimaryKey" resultMap="userVoMap">
12
     select id,username,age,mobile from cskaoyan_user where id = #{id}
13
</select>

resultMap是可以复用的

Lombok#

Lombok: 可以帮助代码在编译的时候生成对应的方法。

1
// getter
2
// setter
3
// toString
4
// hashCode
5
// equals

第一步: 安装插件

第二步: 导包

1
<dependency>
2
       <groupId>org.projectlombok</groupId>
3
       <artifactId>lombok</artifactId>
4
       <version>1.18.12</version>
5
</dependency>

第三步: 使用

1
//@Getter@Setter@ToString@EqualsAndHashCode
2
//@NoArgsConstructor
3
//@AllArgsConstructor
4

5
@Data
6
public class UserVo {
7

8
   private Integer userId;
9
   private String userName;
10
   private Integer userAge;
11
   private String address;
12

13
}

Lombok: 好处

1
// 1. 优势
2
在去修改（增删改）成员变量的时候，不用我们自己再去生成getter、setter等，效率比较高
3

4
// 2. 缺点
5
Lombok在项目中，只要有一个人用了，那么其他的组员也都要使用

MybatisCodeHelperPro#