Web 项目开发时，经常会修改 resource 文件和 Java 文件，往往需要重新部署才能生效。
热部署，即不需要重新部署，就能生效。

以下基于 IDEA 实现热部署

部署方式

两种部署方式：war 和 war exploded

war：将WEB工程以包的形式上传到服务器 ；
war exploded模式：将WEB工程以当前文件夹的位置关系上传到服务器；

（1）war 模式这种可以称之为是发布模式，看名字也知道，这是先打成 war 包，再发布；

（2）war exploded 模式是直接把文件夹、JSP 页面 、classes 等等移到 Tomcat 部署文件夹里面，进行加载部署。因此这种方式支持热部署，一般在开发的时候也是用这种方式。

获取上下文路径时，第一种方式基于 Tomcat 位置；第二种基于项目 target 位置

on update action 与 on frame deactivation

on update action

顾名思义触发 update 时，执行以下哪种动作
update resources —- 更新静态的资源，比如 html,js,css 等 运行模式和调试模式都是立即生效。
update classes and resources —- 更新 java,jsp 和静态资源（
1. Java 修改后，会被编译成。class 然后覆盖到 target/kao 文件夹下，IDE 调试模式的情况下，立即生效。IDE 运行模式下，不立即生效，需要 redeployed 才可生效。
2. JSP 修改后，再次被访问的时候，会自动更新，重新编译成.java—->.class 保存在 Tomcat 的 work 目录下。由于是访问时才检测是否修改，是否需要重新编译，所以 IDE 运行模式 和 IDE 调试模式下，都是立即生效。刷新下页面就可）；
redeployed —– 重新部署，发布到 Tomcat 里，不重启 Tomcat，而是把原来的删掉，然后重新发布；
restart server —– 重启 Tomcat

on frame deactivation

顾名思义 IDEA 窗口失去焦点时，触发以下哪种动作
Do nothing ——— 什么都不做
update resources —- 更新静态的资源，比如 html,js,css 等 运行模式和调试模式都是立即生效。
update classes and resources —- 更新 java,jsp 和静态资源 同上

HTML CSS 修改后不更新

完成上面的操作，很大一部分发现html的修改能够及时更新了，但是js或者jsp的修改却一直没有更新，这是为什么呢？
答案是：浏览器的坑

我是使用的chrome，F12到调试窗口

勾选禁用缓存

总结

on update action 设置为 update classes and resources
on frame deactivation 设置为 do nothing

on frame deactivation 默认也是 do nothing，不然你每次切个窗口，都会更新
值得注意的是，类似于 application 这种配置文件应该是不会更新，需要重新部署才能生效

作者：kevin2020
链接：https://ld246.com/article/1516041883689
来源：链滴
协议：CC BY-SA 4.0 https://creativecommons.org/licenses/by-sa/4.0/

1、JDBC：java DataBase Connectivity 可以为多种关系型DBMS

2、JDBC API 主要功能：

三件事，具体是通过以下类/实现：
DriverManager:管理jdbc驱动

Connection:连接（通过DriverManager产生）

Statement(PreparedStatement) :增删改查（通过Connection产生）
CallableStatement:调用数据库中的存储过程/存储函数（通过Connection产生）

Result:返回的结果集（上面的Statement等产生）

Connection产生操作数据库的对象：

Connection产生Statement对象：createStatement()
Connection产生PreparedStatement对象：prepareStatement()
Connection产生CallableStatement对象：prepareCall();

Statement操作数据库：
增删改：executeUpdate()
查询：executeQuery();

ResultSet:保存结果集 select * from xxx
next():光标下移，判断是否有下一条数据；true/false
previous(): true/false
getXxx(字段名|位置): 获取具体的字段值

PreparedStatement操作数据库：
public interface PreparedStatement extends Statement
因此
增删改：executeUpdate()
查询：executeQuery();
赋值操作 setXxx();

PreparedStatement与Statement在使用时的区别：
① Statement:
sql
executeUpate(sql)
② PreparedStatement：
sql(可能存在占位符？)
在创建PreparedStatement 对象时，将sql预编译 prepareStatement(sql)
executeUpate()
setXxx()替换占位符？

推荐使用PreparedStatement：原因如下：
① 编码更加简便（避免了字符串的拼接）
String name =”zs”;
int age = 23;

stmt:
String sql = “insert into student(stuno,stuname) values(‘”+name+”, “+age+”‘)”;
stmt.executeUpate(sql);

pstmt:
String sql=”insert into student(stuno,stuname) values(?, ?)”;
pstmt = connection.prepareStatement(sql);//预编译SQL
pstmt.setString(1,name);
pstmt.setInt(2,age);
pstmt.executeUpate();

②提高性能（因为有预编译操作，预编译只需要执行一次）
需要重复增加100条数
stmt:
String sql = “insert into student(stuno,stuname) values(‘”+name+”, “+age+”‘)”;
for(100)
{
stmt.executeUpate(sql);
}

pstmt:
String sql=”insert into student(stuno,stuname) values(?, ?)”;
pstmt = connection.prepareStatement(sql);//预编译SQL
pstmt.setString(1,name);
pstmt.setInt(2,age);
for(100)
{
pstmt.executeUpate();
}

③安全（可以有效防止sql注入）
sql注入：将客户输入的内容和开发人员的sql语句混为一体

stmt:存在被sql注入的风险
（例如输入 用户名：任意值’ or 1=1 —
密码：任意值）
分析:
select count() from login where uname=’任意值’ or 1=1 –‘ and upwd=’任意值’; select count() from login where uname=’任意值’ or 1=1;
select count(*) from login;

select count(*) from login where uname='”+name+”‘ and upwd='”+pwd+”‘
pstmt:防止sql注入

3、jdbc访问数据库的具体步骤：

a.导入驱动，加载具体的驱动类
b.与数据库建立连接
c.发送sql，执行
d.处理结果集（查询）

4.数据库驱动

驱动 jar 具体驱动类 连接字符串
Oracle ojdbc-x.jar oracle.jdbc.OracleDriver jdbc：oracle:thin:@localhost:1521:ORCL
MySQL mysql-connector-java-x.jar com.mysql.jdbc.Driver jdbc:mysql://localhost:3306//数据库实例名
SqlServer sql.jdbc-x.jar com.microsoft.sqlserver.jdbc.SQLServerDriver jdbc：microsoft:sqlserver:localhost:1433；databasename=数据库实例名

使用jdbc操作数据库时，如果对数据库进行了更换，只需要替换：驱动、具体驱动类、连接字符串、用户名、密码

1.JSP:动态网页

静态、动态:
a.不用 和 是否有“动感”混为一谈
b.是否 随着 时间、地点、用户操作 的 改变而改变

动态网页 需要使用到 服务端脚本语言（JSP）

2架构

CS:Clinent Server
CS不足：
a.如果 软件升级， 那么全部软件都要升级
b.维护麻烦: 需要维护每一台 客户端软件
c.每一台客户端 都需要安装 客户端软件

BS : broswer Server
客户端可以通过 浏览器 直接访问服务端

注意：bs和cs各有优势。

3.tomcat解压后目录：

bin:可执行文件（startup.bat shuntdown.bat）
conf:配置文件（server.xml）
lib: tomcat依赖的jar文件
log:日志文件（记录出错等信息）
temp：临时文件
webapps: 可执行的项目（将我们开发的项目 放入该目录）
work：存放由jsp翻译成的java，以及编译成的class文件（jsp ->java ->class）

4.配置tomcat

a.配置jdk（必须配置JAVA_HOME）
java_home classPath path
b.配置catalina_home

双击bin/startup.bat启动tomcat
常见错误： 可能与其他服务器的端口号冲突
tomcat端口号默认8080 （此端口号较为常见， 容易冲突），建议修改次端口（8888）

修改端口号：conf/server.xml中找到 port=”8080″ 修改数值即可

5.访问tomcat（默认的端口号8080）

http://localhost:8888/

常见状态码：
200：一切正常
300/301：页面重定向 （跳转）
404：资源不存在
403：权限不足 （如果访问a目录，但是a目录设置 不可见）
500：服务器内部错误（代码错误）
其他编码：积累

jsp：在html中嵌套的java代码

在项目/WEB-INF/web.xml中设置 默认的 初始页面
index.jsp

6.虚拟路径

a.方式一
将web项目配置到 webapps以外的目录
conf/server.xml中配置
host标签中：

docBase: 实际路径
path: 虚拟路径 （绝对路径、相对路径【相对于webapps】）
重启

b.方式二

D:\tomcat\apache-tomcat-9.0.38\conf\Catalina\localhost
中新建 “项目名.xml”中新增一行：

7.虚拟主机

通过www.text.com访问本机
a. conf/server.xml

<Host appBase="D:\study\JspProject"  name="www.text.com">
        <Context  docBase="D:\study\JspProject"    path="/"  />
</Host>

b.C:\Window\System32\drivers\etc\host
增加
127.0.0.1 www.test.com

流程：
www.test.com -> host找映射关系 ->server.xml找Engine的defaultHost ->通过“/”映射到D:\study\JspProject

8.JSP执行流程

jsp-> java(Servlet文件) ->class
D:\tomcat\apache-tomcat-9.0.38\work\Catalina\localhost\JspProject\org\apache\jsp

Jsp 和Servlet 可以相互转换

因为第一次请求服务端 会有翻译 和编译的过程，因此比较慢； 后续访问 可以直接访问class,因此速度较快。但是 如果 服务端修改了代码，则再次访问时 会重新的翻译、编译。

9.使用Eclipse开发Web项目（JSP项目）tomcat 在Eclipse中创建的Web项目：

浏览器可以直接访问 WebContent中的文件
例如HTTP：//localhost:8888/MyJspProject/index1.jsp
其中的index1.jsp就在WebContent目录；
但是WEB-INF中的文件 无法通过客户端直接访问，只能通过请求转发来访问

注意：并不是 任何的内部跳转都能访问WEB-INF;原因是 跳转有2种方式：请求转发、重定向

10.配置tomcat运行时环境

jsp<->Servlet
a.将tomcat/lib中的servlet-api.jar加入项目的构建路径
b.右键项目->Biuld Path -> Add libraryary ->Server Runtime

11.统一字符集编码

a.编码分类：
设置jsp文件的编码（jsp文件中的pageEncoding属性）：

jsp -> java

设置浏览器读取jsp文件的编码(jsp文件中content属性)
一般将上述设置成一致的编码，推荐使用UTF-8
文本编码：
i.将整个eclipse中的文件统一设置（推荐）
ii.设置某一个项目
iii.设置单独文件

9.1 Applet 概述

一种嵌入HTML文档中的Java程序 。

与Application相比，Applet具有明显的优点

1. Web浏览器提供了运行Applet所需要的许多功能
2. Applet是在运行时通过网络从服务器端下载的，因而便于软件的发布和及时更新

Applet也有其局限性

1. 不能在客户机上读写当地文件
2. 不能连接除它所在的服务器以外的其它机器

9.2 JApplet类

一个applet程序需要继承 javax.swing包中的JApplet类

import java.awt.Graphics;
import javax.swing.JApplet; 
public class MyApplet extends JApplet{  
    public void paint(Graphics g) { //重载JApplet类的paint方法
              //参数是Graphics类的对象，是由浏览器传递过来的
         super.paint(g); //调用其超类JApplet类的paint方法
         g.drawString("This is a Java Applet!",25,25); 
     }
 } 

JApplet类提供了applet在浏览器中运行需要具备的特定方法

• 浏览器载入时，要依次运行init、start、paint方法
• 离开浏览器页面时，执行stop
• 退出浏览器时，执行destroy

9.3 绘图

import java.awt.* 导入字体 颜色 图形包

9.4 Swing基础

图形界面设计的一般步骤

1. 选择容器。
2. 确定布局。
3. 向容器中添加组件。
4. 进行事件处理。

应用Swing组件的Applet
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class SwingApplet extends JApplet{
   public void init() {
      Container contentPane=getContentPane();
      contentPane.setLayout(new GridLayout(2,1));
      JButton button=new JButton("Click me");
      final JLabel label=new JLabel();
      contentPane.add(button);
      contentPane.add(label);
      button.addActionListener( new ActionListener(){
         public void actionPerformed(ActionEvent event) {
           String information=JOptionPane.showInputDialog("请输入一串字符");
           label.setText(information);
          }  }  );//创建监听器语句结束
  }//init方法结束  
}

把JApplet换成JFrame，将例9-4的程序改为Application
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
public class SwingApplication {
    public static void main(String[] args){
        JFrame f=new JFrame(“Simple Swing Application”);         
        Container contentPane=f.getContentPane();
        contentPane.setLayout(new GridLayout(2,1));
        JButton button=new JButton("Click me");
         final JLabel label=new JLabel();
         contentPane.add(button);//添加按钮
         contentPane.add(label);//添加标签
        button.addActionListener( new ActionListener(){
            public void actionPerformed(ActionEvent event) {                    
               String information=JOptionPane.showInputDialog("请输入一串字符");
               label.setText(information);
            }  }  );
        f.setSize(200,100);//设置大小
        f.show();//显示
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

9.5 Swing的特点和概念

顶层容器 Swing提供三个顶层容器的类

1. JFrame 实现单个主窗口
2. JDialog  实现一个二级窗口(对话框)
3. JApplet 在浏览器窗口中实现一个applet显示区域

Application和Applet的区别

整合Log4j

通过日志信息，可以阅读mybatis执行情况，观察mybatis实际执行sql语句以及SQL中的参数和返回结果。

常见日志有这些：SLF4J 、Apache Commons Logging、Log4j2、Log4j 、JDK logging。这里我们使用Log4j。

第一步是导入jar包。mybatis.zip文件中的lib目录下有log4j的jar包，如果没有的可以自行去下载。

第二步是在conf中开启日志。在settings标签中开启：

 <settings>
<!--        开启日志，并指定使用的日志-->
        <setting name="logImpl" value="LOG4J"/>
    </settings>

value属性指定了使用的日志类型，如果不指定，MyBatis就会按照以下的顺序去寻找：

SLF4J →Apache Commons Logging→Log4j2→Log4j → JDK logging

尤其要注意name属性的内容严格区分大小写。

第三步编写配置日志输出文件log4j.properties

log4j.rootLogger=DEBUG, stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

第一行表示日志输出debug类型的信息，且输出到标准输出流中，日志级别DEBUG< INFO<WARN<ERROR；第二行表明日志显示的方式是追加显示到控制台中；第三行表示日志显示的样式，可以是平铺的也可以是竖列的；最后一行表示日志信息的输出格式。后面三行不重要。

log4j.properties文件名必须和使用的日志的jar包类型一致，因为在setting中指定了value之后MyBatis会自动寻找这个log4j.properties文件。

延迟加载

延迟加载是指在一对一、一对多、多对一、多对多等设计多个表的查询时，首先查询指定的表的结果，延时查询所关联的表的结果。只有当需要用到关联表的结果时（在java中使用到了所关联表的实体类对象），MyBatis才会根据指定查询的表的外键去查询所关联表的结果。意思是原本查询结果涉及两个表，需要用一个sql语句执行完，查询的范围也是两张表的所有元组，现在延时加载后将一个sql语句分为两个分别查询两张表的语句，首先只执行一个，当需要用到第二个表的结果时再去查询第二个。

首先需要开启延迟加载。延迟加载需要手动开启，在conf.xml文件中要先关闭立即加载，再开启延迟加载：

<settings>
...
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>

先以一对一为例

在Mapper文件中，原来的查询是这样的：

<!--    使用MyBatis提供的resultMap来实现一对一-->
    <select id="queryStudentWithHashMapForFk" parameterType="int" resultMap="person_idCard_map">
        select  p.*,c.*
        from person p inner join personidcard c on p.cardid =c.cardid
        where p.id=#{id}
    </select>
    
    <resultMap id="person_idCard_map" type="Person">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="age" column="age"/>
<!--        对象成员时，如果是一对一映射，就用association;javaType指定改属性的类型-->
        <association property="personIdCard" javaType="PersonIdCard">
            <id property="cardid" column="cardid"/>
            <result property="cardinfo" column="cardinfo"/>
        </association>
    </resultMap>

延迟加载的语句如下：

 <!--    利用延时加载来实现一对一-->
    <select id="queryStudentWithLazyloading" resultMap="person_idCard_lazyload_map">
        select * from person
    </select>

    <resultMap id="person_idCard_lazyload_map" type="Person">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="age" column="age"/>
        <!-- 这里采用延迟加载：在查询人时，并不立即加载身份证-->
        <association property="personIdCard" javaType="PersonIdCard" select="shopkeeper.mapper.personIdCardMapper.queryCardById" column="cardid">
        </association>
    </resultMap>

改变的地方有两处，一是sql语句，现在只需要先查询person表的信息了；二是在resultMap中的association标签，personIdCard这张表并不是直接写出要查询的元素，而是多了select和column两个属性：select表示延时加载时执行的查询语句在mapper文件中的id值，column是这两张表的关联，即外键，作为参数传入select中的查询语句里（column写入的是select标签中查询的表的外键，这里的cardid在两张表中名字是相同的，在一对多的例子中就不相同了）。select引用的语句如下：

<select id="queryCardById" parameterType="int" resultType="personIdCard">
   select * from personidcard where cardid =#{cardid}
</select>

也就是说，一开始我们只得到了person表的查询结果，只有当我们要用到personIdCard的结果时，MyBatis才会动用延时加载来根据外键来找到personIdCard的结果。

可以发现的时select中的语句在另外一个Mapper中，其实写在一个Mapper里也是可以的，但是要遵循一个实体类对应一个Mapper文件的开发习惯。新建了一个mapper文件后一定要记得去conf.xml文件中建立映射。

在测试类中检测延时加载的效果：

public static void queryStudentWithLazyloading() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
    SqlSession sqlSession=sqlSessionFactory.openSession();

    personMapper personMapper =sqlSession.getMapper(personMapper.class);


    List<Person> pers=personMapper.queryStudentWithLazyloading();

    for (Person person:pers)
    {
        System.out.println(person.getId()+", "+person.getName());
    }

    for (Person person:pers)
    {

        PersonIdCard card=person.getPersonIdCard();

        System.out.println(card.getCardid()+", "+card.getCardinfo());
    }

    sqlSession.close();
    reader.close();
}

我是先得到了所有的person表的查询结果，再根据每一个person来获取其idcard的信息。日志输出如下：

DEBUG [main] - Opening JDBC Connection
DEBUG [main] - Created connection 359922172.
DEBUG [main] - Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1573f9fc]
DEBUG [main] - ==>  Preparing: select * from person
DEBUG [main] - ==> Parameters: 
DEBUG [main] - <==      Total: 4
1, 刘茜元
2, 陈曦
3, 刘闹闹
13, 刘咯咯
DEBUG [main] - ==>  Preparing: select * from personidcard where cardid =?
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 1
1, 刘茜元 info
DEBUG [main] - ==>  Preparing: select * from personidcard where cardid =?
DEBUG [main] - ==> Parameters: 2(Integer)
DEBUG [main] - <==      Total: 1
2, 陈曦 info
DEBUG [main] - ==>  Preparing: select * from personidcard where cardid =?
DEBUG [main] - ==> Parameters: 3(Integer)
DEBUG [main] - <==      Total: 1
3, 刘闹闹 info
DEBUG [main] - ==>  Preparing: select * from personidcard where cardid =?
DEBUG [main] - ==> Parameters: 13(Integer)
DEBUG [main] - <==      Total: 1
13, 刘咯咯 info
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1573f9fc]
DEBUG [main] - Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@1573f9fc]
DEBUG [main] - Returned connection 359922172 to pool.

可以很明显地看出查询身份证的操作分了多次进行，且完全在查询人的操作之后。

一对多

和一对一的延迟加载配置方法相同。

在personClassMapper中建立延时加载的查询：

<select id="queryClassAndPersonsWithLazyloading" resultMap="class_person_Lazyload_map">
    select c.* from personclass c
</select>

<resultMap id="class_person_Lazyload_map" type="personclass">
    <id property="classid" column="classid"/>
    <result property="classname" column="classname"/>
    <collection property="persons" ofType="person" column="classid" select="shopkeeper.mapper.personMapper.queryPersonByClassId" >

    </collection>
</resultMap>

select中引用的查询语句：

<select id="queryPersonByClassId" parameterType="int" resultType="person">
    select * from person where class= #{class}
</select>

这里可以发现column中传入的是外键名，classid在personClass表中的名称是classid，但是在person表中的名称只是class。原因是在resultMap中传入参数给延时加载的sql的。

测试类：

public static void queryClassAndPersonsWithLazyloading() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
    SqlSession sqlSession=sqlSessionFactory.openSession();

    personClassMapper personClassMapper =sqlSession.getMapper(personClassMapper.class);


    List<PersonClass> classes=personClassMapper.queryClassAndPersonsWithLazyloading();

    for (PersonClass personClass:classes)
    {
        System.out.println(personClass.getClassid()+", "+personClass.getClassname());
    }

    for (PersonClass personClass:classes)
    {

        List<Person> persons=personClass.getPersons();

        System.out.println(persons);
    }

    sqlSession.close();
    reader.close();
}

日志输出和一对一的差不多。但是这里是使用了personClassMapper中的查询语句，所以要先实现一个接口。

查询缓存

一级缓存

作用范围是同一个sqlsession对象。

MyBatis默认开启一级缓存，当某个查询第一次执行时，会从DB中查询，结果缓存在sqlsession中。之后这一个sqlsession执行同一个语句的所有查询都会直接去sqlSession中取出结果（不会重新去数据库中再进行一次查询）。

每当进行一次commit之后sqlSession就会自动清空所有缓存的结果。

二级缓存

MyBatis自带二级缓存，也有第三方提供的二级缓存。

Mybatis自带二级缓存， 作用范围是同一个namespace生成的mapper对象。默认不打开，需要手动打开：

第一步在conf中开启：

<settings>
...
<!--        开启二级缓存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>

二级缓存就算打开了，也不是所有的Mapper都会使用；如果要使用二级缓存，还需要再Mapper文件中声明开启二级缓存，实现方式是加一个<cache/>标签。

此时如果直接运行测试类，会报以下错错误：

Exception in thread "main" org.apache.ibatis.cache.CacheException: Error serializing object.  Cause: java.io.NotSerializableException: shopkeeper.entity.Person

说明二级缓存是在硬盘中进行的，准备缓存的对象必须实现了序列化接口。需要序列化的对象就是开启了二级缓存的mapper对应的对象（personMapper->person）。这同时也说明了为什么二级缓存的使用需要在每一个Mapper文件中要手动添加一个cache标签：向磁盘io操作很占用系统资源且实体类一般在创建时也不会实现Serializable接口。

此外由可序列化的知识可知：级联和父类都要序列化。

namespace的值就是接口的全类名(包名.类名)，通过接口可以产生代理对象（personMapper等）；而namespace决定了studentMapper对象的产生所以只要产生的Mapper对象来自于同一个namespace，则这些对象共享二级缓存。

如果是同一个SqlSession对象进行多次相同的查询，则直接进入一级缓存查询；当一个SqlSession被close时，就会触发将 一级缓存的内容存入到二级缓存中（貌似commit也会触发，存疑）；如果不是同一个SqlSession对象进行多次相同的查询(但是均来自同一个namespace),则进入二级缓存查询。

测试类方法：

public static void queryClassAndPersonsWithLazyloading() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);//可以通过build的第二参数指定数据库环境
    SqlSession sqlSession=sqlSessionFactory.openSession();

    personClassMapper personClassMapper =sqlSession.getMapper(personClassMapper.class);


    List<PersonClass> classes=personClassMapper.queryClassAndPersonsWithLazyloading();

    for (PersonClass personClass:classes)
    {
        System.out.println(personClass.getClassid()+", "+personClass.getClassname());
    }

    for (PersonClass personClass:classes)
    {

        List<Person> persons=personClass.getPersons();

        System.out.println(persons);
    }

    sqlSession.close();

    SqlSession sqlSession2=sqlSessionFactory.openSession();

    personClassMapper personClassMapper2 =sqlSession2.getMapper(personClassMapper.class);


    List<PersonClass> classes2=personClassMapper2.queryClassAndPersonsWithLazyloading();

    for (PersonClass personClass:classes2)
    {
        System.out.println(personClass.getClassid()+", "+personClass.getClassname());
    }

    for (PersonClass personClass:classes2)
    {

        List<Person> persons=personClass.getPersons();

        System.out.println(persons);
    }

    sqlSession2.close();
    reader.close();
}

运行测试类的日志如下：

DEBUG [main] - ==>  Preparing: select c.* from personclass c
DEBUG [main] - ==> Parameters: 
DEBUG [main] - <==      Total: 2
2, c2
6, c6
DEBUG [main] - Cache Hit Ratio [shopkeeper.mapper.personMapper]: 0.0
DEBUG [main] - ==>  Preparing: select * from person where class= ?
DEBUG [main] - ==> Parameters: 2(Integer)
DEBUG [main] - <==      Total: 1
[Person{age=20, name='陈曦', id=2}]
DEBUG [main] - Cache Hit Ratio [shopkeeper.mapper.personMapper]: 0.0
DEBUG [main] - ==>  Preparing: select * from person where class= ?
DEBUG [main] - ==> Parameters: 6(Integer)
DEBUG [main] - <==      Total: 3
[Person{age=19, name='刘茜元', id=1}, Person{age=19, name='刘闹闹', id=3}, Person{age=19, name='刘咯咯', id=13}]
DEBUG [main] - Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@3eb738bb]
DEBUG [main] - Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@3eb738bb]
DEBUG [main] - Returned connection 1052195003 to pool.
DEBUG [main] - Cache Hit Ratio [shopkeeper.mapper.personClassMapper]: 0.5
2, c2
6, c6
[Person{age=20, name='陈曦', id=2}]
[Person{age=19, name='刘茜元', id=1}, Person{age=19, name='刘闹闹', id=3}, Person{age=19, name='刘咯咯', id=13}]

可以看见当第一次查询时，命中率为0，第二次查询时命中率为0.5，说明第二次用到时二级缓存中的结果。

关联查询

一对一映射

先创建第二张表personidcard和其实体类，然后再给表person添加外码：

alter table person add constraint fk_person_idcard_cardid foreign key (cardid) references personidcard(cardid);

我们需要根据传入的id值来查询一个人的全部信息（person表和personidcard表），sql语句是：

select  p.*,c.*
from person p inner join personidcard c on p.cardid =c.cardid
where p.id=#{id}

但是返回值现在不好处理了，因为这涉及到了两个类中的属性。MyBatis有业务拓展类和resultMap类两种实现方式。

业务拓展类

需要新建一个业务拓展类，使其继承成员变量多的类（person），然后直接代码创建变量少的类的属性：

public class PersonBussiness extends Person{
    private int cardid;
    private String cardinfo;

    public int getCardid() {
        return cardid;
    }

    public void setCardid(int cardid) {
        this.cardid = cardid;
    }

    public String getCardinfo() {
        return cardinfo;
    }

    public void setCardinfo(String cardinfo) {
        this.cardinfo = cardinfo;
    }

    @Override
    public String toString() {
        return super.toString()+", "+this.cardid+", "+this.cardinfo;
    }
}

这样就可以在resultType中写入返回值类型是PersonBussiness了：

<select id="queryStudentWithBussiness" parameterType="int" resultType="personbussiness">
    select  p.*,c.*
    from person p inner join personidcard c on p.cardid =c.cardid
    where p.id=#{id}
</select>

用业务拓展类的核心是用resultType指定类的属性包含多表查询的所有字段。但是这个方法有些弊端，如果有很多张表都有关联，业务拓展类实现起来就很麻烦了。

ResultMap

之前已经多次出现这个resultMap了，给人的感觉是，实现简单的东西比较繁杂，但是可以去做一些特定的任务，给人一种吃力不讨好的感觉。果不其然用resultMap来实现关联查询就十分的方便。

在数据库中通过外键将两个表关联起来，那么在java中将两个类关联起来可以通过将一个类作为另外一个类的成员变量来实现（在person类中增加成员PersonIdCard）。

将PersonIdCard类关联到person类中之后resultMap的返回值就可以直接写Person了：

<select id="queryStudentWithHashMapForFk" parameterType="int" resultMap="person_idCard_map">
        select  p.*,c.*
        from person p inner join personidcard c on p.cardid =c.cardid
        where p.id=#{id}
    </select>
    
    <resultMap id="person_idCard_map" type="Person">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <result property="age" column="age"/>
<!--        对象成员时，如果是一对一映射，就用association;javaType指定改属性的类型-->
        <association property="personIdCard" javaType="PersonIdCard">
            <id property="cardid" column="cardid"/>
            <result property="cardinfo" column="cardinfo"/>
        </association>
    </resultMap>

resultMap中的id和result字段和之前的处理方式一样，现在主要针对于对象类型，即关联的personidcard类的处理。如果是一对一映射就用association标签；如果是一对多就是collection标签。在association标签中还需要加上这个成员变量的名称property和类型javaType。

这个关联类中也有自己的成员变量，其本身也对应了一张表，所以也要写上自身的变量，同样是用id和result。

一对多映射

新建另一张表personClass和其实体类，给person添加外码class。然后说一个题外话：Mysql不允许同时更新（删除）和查询同一张表，是我在尝试以多此一举的方式更新表的时候发现的这个问题。

由于还是用ResultMap来实现，所以要将personClass和person这两个类关联起来。现在是一对多的联系，只能在personClass类中增加person的list。

在resultMap中，其它的写法全都一样，唯一不同的是，现在关联的类是一对多关联，要写collection（一对一写association），并且描述类型的时候不能再用javatype了（因为javaType不用写list，而单写一个person不能正确表示personClass当中的成员的类型，也不能体现其是一对多关联），而是特有的ofType，然后ofType里面写person，表明这个集合的元素类型是person：

<select id="queryClassAndPersons" parameterType="int" resultMap="class_person_map">
        select c.*,p.*
        from person p
        inner join personclass c on c.classid=p.class
        where p.class=#{class}
    </select>

    <resultMap id="class_person_map" type="personclass">
        <id property="classid" column="classid"/>
        <result property="classname" column="classname"/>
<!-- 描述属性类型javaType
 描述属性的元素类型是oftype-->
        <collection property="persons" ofType="person">
            <id property="id" column="id"/>
            <result property="name" column="name"/>
            <result property="age" column="age"/>

        </collection>
    </resultMap>

然后collection标签内依旧要配置person的成员属性。

动态SQL

动态SQL能够根据输入的参数而确定最终提交给数据库的SQL语句。当传入的参数满足一定的条件时，MyBatis就会相应地拼接对应的语句，且能够自动地处理空格、逗号和语句头部的连词。

动态SQL需要用到if、where、foreach等标签来实现。

if标签

if标签时动态SQL的灵魂，分支条件全都要if标签的test属性来实现。如果test当中的语句结果为真，就将这个if标签中的sql语句拼接到总的sql语句中：

<select id="queryPerosnByNameOrAgeWithSQLTag" parameterType="person" resultType="person">
        select id,name,age from person where 
        <if test="name!=null and name!=''">
            name=#{name}
        </if>
        <if test="age!=null and age!=0">
            and age=#{age}
        </if>

    </select>

Person person=new Person();
        person.setName("刘咯咯");
        person.setAge(19);
        Person pers=personMapper.queryPerosnByNameOrAgeWithSQLTag(person);

where标签

if标签是按照代码的顺序执行的，如果第一个条件不成立，且有第二个条件成立的话，由于第二个if标签中的sql语句首部必然有连接词and或or，那么将其与原sql语句拼接之后必然会导致sql语句解析错误。

可以巧妙地在where后面加一句1=1，就可以暂时解决这个问题了：

    <select id="queryPerosnByNameOrAgeWithSQLTag" parameterType="person" resultType="person">
        select id,name,age from person where 1=1
        <if test="name!=null and name!=''">
            and name=#{name}
        </if>
        <if test="age!=null and age!=0">
            and age=#{age}
        </if>

    </select>

但是还是有一个问题，1=1对于or来讲就是恒真了，会屏蔽所有or后i按的语句，你说加一句1<>1吧，又防不了and语句，所以MyBatis推出了更加灵活的where标签来处理这问题：

<select id="queryPerosnByNameOrAgeWithSQLTag" parameterType="person" resultType="person">
    select id,name,age from person
    <where>
        <if test="name!=null and name!=''">
            and name=#{name}
        </if>
        <if test="age!=null and age!=0">
            and age=#{age}
        </if>
    </where>
</select>

将所有的if标签都写入where标签内，where语句会处理第一个成立的if标签中的and（或者or）。这个时候哪怕第一个if中写上了and或test不通过，也能够拼接成正确的语句。不过where只会处理第一个成立的if标签，如果之后的标签中缺少连接词的话研究会报错。

foreach标签

foreach标签是为了让动态SQL能够处理in语句中的内容，例如查询编号为1、2、13的人的信息：

select id, name from person where id in(1,2,13)

我们想让in后面的那个集合能用动态SQL的方式动态传入。显然多个元素的话需要遍历每一个元素来查询，如果企图直接通过读取属性的方式是行不通的，例如定义一个Country类，其中有一个成员变量list为ids，在下面的语句中，会报无法识别ids的错误：

<select id="queryPersonWithIdInCountry" parameterType="Country" resultType="person">
        select * from person
        <where>
            <if test="ids!=null and ids.size>0">
                and id in(ids)
            </if>
        </where>

</select>

foreach看名字就知道是实现迭代的功能。foreach可以迭代的类型有：属性、数组（包括对象数组）、集合等。

属性

还是以上面的那个country中的属性ids为例，想要用foreach处理它，实现起来就和java中的增强for差不多：

<select id="queryPersonWithIdInCountry" parameterType="Country" resultType="person">
    select * from person
    <where>
        <if test="ids!=null and ids.size>0">
        <foreach collection="ids" open=" and id in(" close=")" item="id" separator=",">
            #{id}
        </foreach>

        </if>
    </where>
</select>

collection中写属性名，item中写入每一次遍历取出的值（相当于for (String name: [names])中的name）；由于一个sql语句中不止要遍历的集合，还包括语句中的其它部分，所以用open写入要迭代的元素的前面的内容，用close写入后面的内容。最后还需要定义分隔符，用separator来写。

foreach标签内写入展位符，表示要迭代的部分的取值。所以整个sql语句就被拆成了这样：

select * from person【open】and id in(【item】#{id}【separator】，【item】#{id}【close】）

简单类型的数组

当传入的是简单类型的数组时，不仅输入参数的类型要改为对应的数组类型，而且在使用时需要用array来代替所有的数组名。原因时数组名时作为形参传入进来的，无法写成映射。

<select id="queryPersonWithArray" parameterType="int[]" resultType="person">
    select * from person
    <where>
        <if test="array!=null and array.length>0">
            <foreach collection="array" open=" and id in(" close=")" item="id" separator=",">
                #{id}
            </foreach>
        </if>
    </where>
</select>

集合类型（list）

和传入简单类型的数组差不多，将传入的参数写为list，且将所有集合名写为list：

<select id="queryPersonWithList" parameterType="list" resultType="person">
    select * from person
    <where>
        <if test="list!=null and list.size>0">
            <foreach collection="list" open=" and id in(" close=")" item="id" separator=",">
                #{id}
            </foreach>

        </if>
    </where>
</select>

对象数组

假设要传入一个person类的数组：

Person per1=new Person();
per1.setId(1);
Person per2=new Person();
per2.setId(2);
Person per13=new Person();
per13.setId(13);

Person persons[]=new Person[]{per1,per2,per13};

现在传入的类型并不能写Person[]了，会报错无法识别这个别名，只能传入Object[]（我觉得挺迷的，为什么parameterType写单个Person类就可以写Person数组就不行了）。

<select id="queryPersonWithObjectArray" parameterType="Object[]" resultType="person">
    select * from person
    <where>
      <if test="array!=null and array.length>0">
          <foreach collection="array" open=" and id in(" close=")" item="person" separator=",">
             #{person.id}
          </foreach>
      </if>
    </where>
</select>

现在每一次迭代取出的都是一个person实例，真正要用的其实时person实例中的id变量，所以在占位符中要写item中的临时变量（person）点id。

SQL片段

对于需要重复出现很多次的代码，在java中可以将其写入一个方法中，在SQL里可以写入存储过程或存储函数中。那么在MyBatis中，可以使用SQL片段处理可能需要多次出现的SQL语句。

第一步要提取相似代码。 在Mapper.xml文件中的namespace标签下写sql标签（与增删改查的标签同级），在sql标签中写入需要提取的代码：

<sql id="queryWithObjectArray">
    <where>
        <if test="array!=null and array.length>0">
            <foreach collection="array" open=" and id in(" close=")" item="person" separator=",">
                #{person.id}
            </foreach>
        </if>
    </where>
</sql>

sql标签的id属性作用与增删改查的id相同，唯一标识这个SQL片段。

第二步引用。在需要引用的地方写入refield标签，补充完id值之后就可以引用完成了：

<select id="queryPersonWithObjectArray" parameterType="Object[]" resultType="person">
    select * from person
    <include refid="queryWithObjectArray"></include>
</select>

如果引用的地方不在SQL片段同一个文件，需要在引用时加上namespace。

spring aop通知(advice)分成五类：

1. 前置通知[Before advice]：在连接点前面执行，前置通知不会影响连接点的执行，除非此处抛出异常。
2. 后置通知[After returning advice]：在连接点正常执行完成后执行，如果连接点抛出异常，则不会执行。
3. 异常通知[After throwing advice]：在连接点抛出异常后执行。
4. 返回通知[After (finally) advice]：在连接点执行完成后执行，不管是正常执行完成，还是抛出异常，都会执行返回通知中的内容。
5. 环绕通知[Around advice]：环绕通知围绕在连接点前后，比如一个方法调用的前后。这是最强大的通知类型，能在方法调用前后自定义一些操作。环绕通知还需要负责决定是继续处理join point(调用ProceedingJoinPoint的proceed方法)还是中断执行。

接下来通过编写示例程序来测试一下五种通知类型：

非注解方式

前置通知

定义aop类

• method：被调用的方法，就是连接点
• objects：被调用方法的参数
• o：调用被调用方法的对象

xml文件

注意要先在ioc容器中放入对象才能使用id引用。

 <bean id="logBefore" class="com.cztcode.spring.aop.LogBefore"/>
    <aop:config>
        <aop:pointcut id="point" expression="execution(public void com.cztcode.spring.impl.StudentServiceImpl.addStudent(com.cztcode.spring.entity.Student))"/>
<!--        关联ref，当执行点时，执行advice-->
        <aop:advisor advice-ref="logBefore" pointcut-ref="point"/> 
    </aop:config>

执行结果

后置通知

后置通知与前置类似，只是参数和接口不同

多了一个

• returnValue：方法返回值

xml文件

执行结果

异常通知

Exception：异常类型

环绕通知

环绕通知很强大，上面那三个通知都可以做到。

xml文件配置方法相同。

如果invocation.proceed()没有写，那么这个切入点方法就不会被执行。但是环绕方法的通知会执行。

环绕通知底层通过拦截器实现。

注解形式

前置和后置通知

开启扫描器和对AOP注解支持

实现效果

异常通知

截获某种异常

若发生异常通知，后置通知将不会触发

环绕通知

最终通知

其实在环绕通知中已经实现了最终通知

详解ResultType

简单类型

八个基本类型+String。举例：

<select id="queryPersonCount" resultType="int">
    select count(*) from person
</select>

接口方法：

int queryPersonCount();

输出参数为实体对象类型

举例：

<select id="queryPersonById" resultType="person" parameterType="int">
    select * from person where id=#{id}
</select>

接口方法：

Person queryPersonById(int id);

输出参数为实体对象类型的集合

有多个查询结果的情况。举例：

<select id="queryAll" resultType="person">
    select * from person
</select>

接口方法：

List<Person> queryAll();

虽然输出类型为集合，但是resultType依然写集合的元素类型(resyltType=”person”)，接口中的方法返回值要写集合类型list。

输出参数类型是HashMap

若返回值为HashMap，就需要有键值对。MyBatis实现的方式是在sql语句中给要查询的列名起一个别名，让别名作为key，查询的结果作为对应的value。举例：

<select id="queryPersonOutByHashMap" resultType="HashMap">
    select id "mId", name "mName" from person where id=1
</select>

接口方法：

HashMap<String,Object> queryPersonOutByHashMap();

测试类中获取结果：

//查询人，返回值为HashMap
public static void queryPersonOutByHashMap() throws IOException {
    ...
    HashMap<String,Object> personMap=personMapper.queryPersonOutByHashMap();

    System.out.println(personMap);
    ...
}

以上是查询只有一个返回的结果，如果有多个结果，那么xml文件中的resultType依旧是HashMap，但是接口方法需要用list（同第三种）。举例：

<select id="queryAllPersonOutByHashMap" resultType="HashMap">
    select id "mId", name "mName" from person
</select>

接口方法：

List<HashMap<String,Object>> queryAllPersonOutByHashMap();

测试类中获取结果：

//查询人，返回值为HashMap的集合
public static void queryAllPersonOutByHashMap() throws IOException {
    ...
    List<HashMap<String,Object>> personMaps=personMapper.queryAllPersonOutByHashMap();

    System.out.println(personMaps);
    ...
}

当属性名和字段名不一致时

之前是使用ressultMap来实现的：

<select id="queryPersonByIdWithConverter" resultMap="resultPerson" parameterType="int">
    select * from person where id=#{id}
</select>
<resultMap id="resultPerson" type="person">
    <id property="num" column="id"/>
    <result property="name"  column="name"/>
    <result property="age" column="age"/>
    <result property="sex" column="sex" javaType="boolean" jdbcType="INTEGER"/>
</resultMap>

接口方法：

Person queryPersonByIdWithConverter(int id);

实际上还可以用resultType+HashMap的方式解决（前提是将实体类person中的id和name变量暂时改为mId和mName：

<select id="queryAllPersonOutByHashMap" resultType="person">
        select id "mId", name "mName" from person
</select>

这么做的原理是，MyBatis根据sql语句中起的别名，将别名自动与person进行映射（原先是将实体类的属性和列名映射）。相当于MyBatis在自动映射时多了应该选择。

上面的当返回值时为HashMap的情况也用到了别名，但是这个别名是MyBatis拿过来作为HashMap的key值的，实现的道理不一样。

我们可以发现当属性名和字段名不一致时，使用resultType+HashMap比使用resultMap要简洁很多。我认为一般写resultMap主要是为了使用类型转换器。

详解parameterType

Mapper.xml的每一个sql标签的parameterType属性表示输入参数，并且在sql语句中，用#{}或${}来从parameterType中取得对应的值。当输入参数的类型不同时，#{}和${}的用法有很大的区别。

基本类型

当输入参数时八个基本类型或string类型时，#{}和${}既有相似之处，又有不同的用法：

不同

第一、基本类型中#{}中的内容可以写任意值，如# {xxx}；而${}中必须写value，如$ {value}（但是在新的jar包中取消了这一限制，所以这一点没有什么区别了）。

第二、对于String类型，#{}会自动给里面的参数套上单引号’ ‘，然而${}会进行原样输出，那么以下这个语句：

<select id="queryPersonByName" resultType="person" parameterType="string">
    select * from person where name= ${values} 
</select>

实际上提交给数据库的是

select * from person where name= 刘咯咯 ;

这个语句显然在sql中是不成立的，原因是数据库的字符串要加上单引号。需要改写成以下的样子：

<select id="queryPersonByName" resultType="person" parameterType="string">
    select * from person where name='${value}'
</select>

但是${}在动态排序里面就有很大的作用。一个根据输入的列名的排序语句如果用#{}写是这样的：

<select id="queryPersonOrderedByColumn" resultType="person" parameterType="string">
    select * from person order by ${column } desc
</select>

将列名带入后实际上的sql语句是：

<select id="queryPersonOrderedByColumn" resultType="person" parameterType="string">
    select * from person order by 'name' desc
</select>

‘name’是一个常量，比较无结果，所以这个时候不能用#{}自动生成单引号。

第三、#{}可以防止SQL注入而${}不防止。sql注入是什么我现在也不知道，等以后要用到再说吧，参考资料。

相同

都可以获取对象的值(嵌套类型对象)

第一、在模糊查询中，这两种方式虽然写法稍有不同，但是都能实现：

#{}

<select id="queryPersonByNameOrAge" resultType="person" parameterType="person">
    select * from person where name like #{name} or age=#{age}
</select>

Person person=new Person();
person.setAge(19);
person.setName("%刘%");

${}

<select id="queryPersonByNameOrAge" resultType="person" parameterType="person">
    select * from person where name like '%${name}%' or age=#{age}
</select>

Person person=new Person();
person.setAge(19);
person.setName("刘");

第二、获取对象的值的方式相同

原来直接传入的是person类的实例，现在新建一个类address，根据address的值来查询。可以直接将address作为输入参数传入：

<select id="queryPersonByAddress" resultType="person" parameterType="address">
    select * from person where homeaddress=#{homeAddress} or schooladdress='${schoolAddress}'
</select>

也可以直接获取嵌套对象的值（传入person获取其address）：

<select id="queryPersonByAddress" resultType="person" parameterType="person">
    select * from person where homeaddress=#{address.homeAddress} or schooladdress='${address.schoolAddress}'
</select>

对象类型

当parameterType的取值是对象类型时，使用#{}和${}都必须写属性名：

<select id="queryPersonByNameOrAge" resultType="person" parameterType="person">
        select * from person where name like '%${name}%' or age=#{age}
    </select>

如果输入的值为多个，还可以用HashMap来作为parameterType的取值：

<select id="queryPersonByNameOrAgeWithHashMap" resultType="person" parameterType="HashMap">
    select * from person where name like '%${mName}%' or age=#{mAge}
</select>

传入的HashMap，key的值去匹配占位符，如果名称相同就用value去替换掉占位符：

Map<String,Object> personMap=new HashMap<>();
personMap.put("mName","刘");
personMap.put("mAge",20);
List<Person> persons=personMapper.queryPersonByNameOrAgeWithHashMap(personMap);

parameterType用HashMap来作为输入参数的一个重要用途是调用存储过程。这一点是仅仅传入一个实体类对象是无法实现的。

parameterType为HashMap时调用存储过程

存储过程无论输入参数是什么值，语法上都需要用map来传递该值.

首先在数据库中先创建两个存储过程：

1.查询某个年龄的总人数

DELIMITER //
create PROCEDURE queryCountByAgeWithProcedure (IN mAge int, OUT pNum int)
begin
select count(1) into pNum from person where age=mAge;
end
//
DELIMITER ;

2.根据id值来删除一个人的信息

DELIMITER //
Create procedure deletePersonByIdWithProcedure(In mId int)
Begin 
Delete from person where id =mId;
End
//
DELIMITER ;

mysql中创建存储过程要先将分隔符改成别的东西。参考资料

Mapper.xml

除了parameterType为HashMap之外，还需要写上一个statementType=CALLABLE以表示这个语句是执行的存储过程。之前所有的sql标签都没有写是因为statementType默认值是PREPARED；此外statementType还有一个类型是STATEMENT，表示直接操作sql，不进行预编译：

<select id="queryCountByAgeWithProcedure" statementType="CALLABLE" parameterType="HashMap">
    ...
</select>

通过关键字CALL来调取存储过程，调用的存储过程还需要写明参数的名称、类型、模式，CALL需要在大括号中调用：

<select id="queryCountByAgeWithProcedure" statementType="CALLABLE" parameterType="HashMap">
    {
        CALL queryCountByAgeWithProcedure(
            #{mAge,jdbcType=INTEGER,mode=IN},
            #{pNum,jdbcType=INTEGER,mode=OUT}
        )
    }
</select>

测试类方法

在测试类中，输入的参数还是和上面的一样用HashMap的put方法，同样也是要让key值和占位符匹配。不过在MyBatis中所有的存储过程的方法都没有返回值——返回值存储在HashMap中，所以接口中的方法返回值是void类型:

public interface personMapper {

    ...

    void queryCountByAgeWithProcedure(Map<String,Object> para);
    void deletePersonByIdWithProcedure(Map<String,Object>para);

}

从HashMap中取出存储过程的返回值的方式：

//用存储过程来查询年龄总人数
public static void queryCountByAgeWithProcedure() throws IOException {
    ...

    Map<String,Object> map=new HashMap<>();
    map.put("mAge",19);
    personMapper.queryCountByAgeWithProcedure(map);

    Object pNum=map.get("pNum");
    System.out.println("查询到"+pNum+"人");
    
    ...
}

存储过程的增删改也都需要在最后commit()一下：

//用存储过程来根据id删人
public static void deletePersonByIdWithProcedure() throws IOException {
    Reader reader=Resources.getResourceAsReader("conf.xml");
    SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(reader);
    SqlSession sqlSession=sqlSessionFactory.openSession();

    personMapper personMapper =sqlSession.getMapper(personMapper.class);

    Map<String,Object> map=new HashMap<>();
    map.put("mId",4);
    personMapper.deletePersonByIdWithProcedure(map);
    sqlSession.commit();

    sqlSession.close();
    reader.close();
}

jdbcType

jdbcType这个东西是MyBatis独有的，对应还有一个是javaType。虽然说java的类型能直接和数据库的类型映射，但是当java的一个变量的值是null时，数据库可能只知道其为空值，但是不知道它的具体类型是什么。

例如当parameterType为HashMap的时候，我们定义的HashMap的value类型是Object，此时如果value=null，那么数据库就无法将这个null和自己的类型进行匹配。所以Mybatis在实现可能存在未知类型的空值时要求用上jdbcType，以告诉数据库这是一个什么样的空值。

但是一般情况下数据的类型时可以确定的（例如直接写明parameterType的类型），myBatis可以直接将类型告诉给数据库，此时就不是一定要加上jdbcType了。

jdbcType和javaType的对应关系