MyBatis
1.【入门程序的表】
id 主键
car_num 汽车编号
brand 品牌
guide_price 厂家指导价格 decimal类型 专门为财务数据准备的类型
produce_time 生产时间
car_type 汽车类型
【* 1.resources:】 放在这个目录当中的一般都是资源文件，配置文件
直接放到resources目录下的资源，等同于放到了
类的根路径下
【* 2.开发步骤】 MyBatis001-Entry --- MyBatisEntryTest
第一步： 打包方式jar
<packaging>jar</packaging>
第二步：引入依赖
-mybatis依赖
-mysql依赖
第三步： 编写mybatis核心配置配置文件 ：mybatis-config.cml
注意： 第一 这个文件名表示固定的，只是大家都这样叫
第二 这个文件存放的位置也不是固定的，可以随意 ，但一般情况下会放到根路径下
第四步： 编写xxxMapper.xml文件
在这个配置文件当中编写sql的语句
这个文件名也不是固定的，只是大家都这么写
第五步： 在mybatis-config.xml文件当中指定XXXMapper.xml文件的路径
<mapper resource="CarMapper.xml"/>
注意，resource属性会自动从类的根路径下查找资源，而放在resources当中的资源文件等同于根路径下
第六步： 编写MyBatis程序（使用mybatis类库，编写mybatis程序，连接数据库，做增删改查就可以）
在mybatis当中，负责执行sql语句的对象叫做 SqlSession
第七步： 怎么获取SqlSession对象 （SqlSessionFactoryBuilder一般是一个数据库一个）
SqlSessionFactoryBuilder >> 通过build方法获取SqlSessionFactory >> SqlSession
SqlSessionFactoryBuilder这个的build方法一般要传入一个数据流
列子：：InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
SqlSessionFactory build1 = sqlSessionFactoryBuilder.build(is);
第八步： 执行了sql语句，需要手动提交事务
SqlSession.commit();
重点：只要你的autoCommit是true 就表示你没有开启事务
* 3. 从XML当中构建SqlSessionFactory
第一：在Mybatis中一定有一个很重要的对象，这个对象就是SqlSessionFactory
【* 4。mybatis主要有两个配置文件】
其中一个是：mybatis-config.xml 这个是核心配置文件，主要配置连接数据库的信息等（一般是一个数据库一个）
另一个是：XXXMapper.xml 这个文件是专门用来编写SQL语句的配置文件（一般是一个表一个）
【5.mybatis当中的小细节】
* mabatis中的sql语句可以使用;结尾，也可以不用
* Resources.getResourceAsStream（）一般来说，以Resource这个单词的都是先从类的根路径下去查找
【日志】
开启日志的方式
在mybatis-config.xml文件当中添加settings标签进行开启即可
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings> （STDOUT_LOGGING这个是mybatis的标准日志）
【集成日志logback】
在pom当中引入logback的日志依赖 这个日志框架实现了slf4j日志
然后在根路径下创建logback.xml文件编写输出格式
-----------------------------------------------------------------------------------------------
【使用mybatis实现增删改查】 MyBatis002-crud
实际上，mybatis当中的sqlId完整的写法是
namespace.id
mybatis当中与jdbc不同的是 “？”等同于“#{}”用后者代替了前者
//执行sql语句 insert方法的参数，第一个参数是CarMapper.xml文件当中的id,第二个参数是封装数据的对象
如果传入的第二个参数是一个map集合：
#{这里写的是map集合当中的key}如果key不存在，获取的是null
如果传入的第二个参数是一个pojo类：
#{这里写的是pojo类属性名} 严格意义上来说，这里写的是get方法的方法名去掉get，然后将身下的首字母单词小写
例如 getId（） 》》 #{id}
如果占位符只有一个，那么#{}这里面可以随便写，但是见名知意最好
【如果是查询的话】
如果是查询的语句的话，需要在mapper.xml文件的查询语句当中设置resultType （指定结果集要封装的java对象类型告诉mybatis）
例子： <select id="selectById" resultType="com.bjpowernode.mybatis.pojo.Car">
select id,car_num as carNum, brand ,guide_price as guidePrice,
produce_time as produceTime,car_type as carType
from t_car where id = #{id}
</select>
（这里需要更改列名的原因列名必须和你所创建的pojo类的属性名字一致）
resultType这个属性用来告诉mybatis查询结果集封装成什么类型的数据
重点：：在数据库当中的列名和你创建的pojo类的属性名不一致的话，会导致你的查询结果值为null
所以可以使用起别名，将数据库的列名起为属性名，或者在创建pojo类的时候注意和数据库的名字一致
-----------------------------------------------------------------------------------------------
【mybatis核心配置文件】 mybatis003-configuration
<environments default="development">（default表示默认使用的环境）
<properties resource="jdbc.properties">
在properties标签中可以配置很多属性，name为key，后面的为值
<property name="jdbc.driver" value="com.mysql.cj.jdbc.Driver"/>
<property name="jdbc.url" value="jdbc:mysql://localhost:3306/ziv_mybatis2"/>
<property name="jdbc.username" value="root"/>
<property name="jdbc.password" value="123456"/>
</properties>
【导入工具文件】 >>上面的等同于在rescources当中创建jdbc.properties，将信息写进去在
<!--直接将我们的配置文件放进来-->
<properties resource="jdbc.properties"/>
【起别名】
<typeAliases>
<typeAlias type="com.bjpowernode.mtbatis.pojo.Car" alias="car"/>
假如你那个包下的很多类需要起别名，就可以使用
<package name="这里写你的包名"/>起的别名就是类的简称
</typeAliases>
<!--一个environment对应一个数据库，也是一个环境-->
<!--一个环境environment对应一个SqlSessionFactory对象-->
<environment id="development">
(id就是这个环境的标识)
<transactionManager type="JDBC"/>
（transactionManager标签
作用：：配置事务管理器
type有两个值： JDBC MANAGED
）
<dataSource type="POOLED">
（
dataSource被称为数据源
作用：：为程序提供Connection对象
type属性有三个值：：type=[UNPOOLED|POOLED|JNDI]
UNPOOLED:不使用数据库连接池技术，每一次请求过来都创建新的connection对象
POOLED:使用mybatis自身带的连接池
JNDI:
）
<property name="driver" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
（
这里的话需要使用${在这里写我们jdbc.properties当中写的属性名}
）
</dataSource>
</environment>
</environments>
----------------------------------------------------------------------------
【web应用当中使用mybatis框架】 mybatis004-web
6.4 MyBatis对象作用域以及事务问题
SqlSessionFactoryBuilder
这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。
因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。
你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，
但最好还是不要一直保留着它，以保证所有的 XML 解析资源可以被释放给更重要的事情。
SqlSessionFactory
SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。
使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏习惯”。
因此 SqlSessionFactory 的最佳作用域是应用作用域。 有很多方法可以做到，
最简单的就是使用单例模式或者静态单例模式。
SqlSession
每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，
所以它的最佳的作用域是请求或方法作用域。 绝对不能将 SqlSession 实例的引用放在一个类的静态域，
甚至一个类的实例变量也不行。 也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，
比如 Servlet 框架中的 HttpSession。
如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。
换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。
这个关闭操作很重要，为了确保每次都能执行关闭操作，
你应该把这个关闭操作放到 finally 块中。 下面的示例就是一个确保 SqlSession 关闭的标准模式：
try (SqlSession session = sqlSessionFactory.openSession()) {
// 你的应用逻辑代码
}
1
2
3}
【ThreadLocal线程】
使用Threadlocal解决事务问题
ThreadLocal<SqlSession> local = new ThreadLocal<>();创建thread对象
local.set(sqlSession);存数据
local.get(sqlSession);取数据
local.remove();删除数据
因为我们线程往里面存了数据，使用完毕不删除的话，下一个人调用get方法的话拿到的是之前的对象
所有，我们一般使用完毕都是及时删除
-----------------------------------------------------------------
【javassist】 javassist-test （这个是讲解javassist）
--add-opens java.base/java.lang=ALL-UNNAMED
--add-opens java.base/sun.net.util=ALL-UNNAMED
使用javassist的话要将这两个参数配置进去
【我们在写工具类当中具体的代码文件的时候，我们需要知道具体是什么类型的sql语句】
//需要知道是什么类型的sql语句
/【XXXMapper.xml当中的sqlid不能随便写，namespa必须是dao接口的全名称，id必须是dao接口当中的方法名】
String sqlId = daoInterface.getName()+"."+method.getName();
SqlCommandType sqlCommandType = sqlSession.getConfiguration().getMappedStatement(sqlId).getSqlCommandType();
【在实际应用当中，我们可以不用去写这个方法，因为mybatis框架已经帮我们封装好了这个工具类方法】
因为我们SqlSession对象有一个getMapper方法，就可以获取这个对象
//这个工具类是我们自己写的获取方法
/*private AccountDao accountDao = (AccountDao) GenerateDaoProxy.generate(SessionUtil.getSqlSession(), AccountDao.class);*/
//这一个的话，就是我们mybatis接口代理机制自带的获取方法
private AccountDao accountDao = SessionUtil.getSqlSession().getMapper(AccountDao.class);
-----------------------------------------------------------------------------------
【使用mybatis代理机制，面向接口进行crud】 mybatis005-crud2
这里的话，我们创建接口一般起名为mapper--XXMapper而表示dao---xxxDao
直接使用的SqlSession.getMapper(接口包名.class文件) 》》》这里是返回的 sqlMapper对象
-------------------------------------------------------------------------------------
【使用mybati的小技巧】 mybatis006-antic
* 1.#{}和${}的区别
#{}低层使用的是PreparedStatement,特点，先进行编译然后给sql语句的？传值
${}底层使用Statement 特点：先进行sql语句的拼接，然后再对sql语句进行编译，存在sql注入的风险
优先使用#{} 那什么情况用${}勒
比如我们查询结果根据日期排序，但是asc或者desc是我们传入方法的参数
就是先拼接，在编译就使用${}；
#{}这个传值一般都是带入的‘’单引号
${}而这个拼接的话不会，直接将数据拼接到sql语句当中
下面这个是按照日期时间排序查询所有数据
select id, car_num as carNum, brand, guide_price as guidePrice,
produce_time as produceTime,
car_type as carType
from t_car
order by produce_time ${ascOrDesc}
*2.日志log的设置
日志文件一般是t_log_时间，所以我们一般可以这样使用${}将时间拼接过去查询日志信息
select * from t_car_${time};
*3.批量删除
delete from t_car where id in(${ids});
这里的ids是一个字符串，我们使用${}将这个字符串拼接到sql语句当中
*4.模糊查询
需求，根据汽车的类型进行模糊查询
select * from t_car where car like '%燃油%';(汽车类型是燃油类型的查询出来)
第一种方案： '%${brand}%' 为什么不能直接使用#{}，因为？在''这个里面
第二种方案: concat函数，这个函数是mysql数据库当中的一个函数，专门用户字符串的拼接
concat('%',#{brand},'%')
第三种方案：使用的比较多
"%"#{brand}"%"
*5.起别名】
<typeAliases>
<typeAlias type="com.bjpowernode.mtbatis.pojo.Car" alias="car"/>
假如你那个包下的很多类需要起别名，就可以使用
<package name="这里写你的包名"/>起的别名就是类的简称
</typeAliases>
*6.mybatis-congfig.xml文件当中的mappers标签
<mapper resource="XXXmapper.xml">要求类的根路径下必须有这个文件
<mapper url="">这个的话将文件的路径放过来
<mapper class="">这里写的是全限定接口名字，带有包名
mapper标签的属性可以有三个
resource：这种方式是从类的根路径下开始查找
url：这种方式是一种绝对路径
class这个位置提供的是mapper接口的全限定名称，他会去那个接口的同级目录下开始查找
所以我们创建resources下创建目录，而且目录名字必须和接口的包名一致
提醒！！！！在idea当中的resources当中创建多重目录的话，我们需要使用的是com/bjpowernode/mybatis等等
*7.使用自动生成主键值
<!--useGeneratedKeys这个是使用自动生成主键值
keyProperty指定主键值赋值给那个对象的那个属性，这个就表示将主键值赋值给car对象的id属性
-->
<insert id="com.bjpowernode.mtbatis.pojo" useGeneratedKeys="true" keyProperty="id">
insert into t_car values (null,#{carNum},#{brand},#{guidePrice},#{produceTime},#{carType})
</insert>
--------------------------------------------------------------------------------------------------
【参数的传值】 mybatis007-param
1.xml文件当中的parameterType的作用
告诉mybatis框架，我这个方法的参数类型是什么类型
但是mybatis自身带有自动推断机制，所有大部分情况下可以不写
<select id="selectById" resultType="student" parameterType="long">
select * from t_student where id = #{id}
</select>
2.10种简单类型：
byte,short,int,long,float,double,char,string,java.util.Date,java.sql.Date
3.单个参数
我们传入参数需要写参数的类型，但是mybatis自动判断机制强大，可以不写
<insert id="insertByStudent" parameterType="student" useGeneratedKeys="true" keyProperty="id">
insert into t_student values (null,#{name},#{age},#{height},#{brith},#{sex})
</insert>
（parameterType这个的话就是传入参数的类型，useGeneratedKeys开启主键自动赋值 keyProperty赋值给那个属性）
4.多个参数传值
如果是多个参数的传值的话，mybatis框架底层是怎么做的呢？
mybatis框架会自动创建一个Map集合，别且Map集合是以这种方式储存参数的：
map.put("arg0",参数1)
map.put("arg1",参数2)
map.put("param1",参数1)
map.put("param2",参数2)依次储存
----------------------------------------------------------------------------
【查询专题】 mybatis008-selectreturn
1.返回Map集合
<select id="selectByIdReturnMap" resultType="map">
select * from t_car where id = #{id};
</select>
只需要在那个resultType当中定义返回类型为map集合就可以
2.返回一个大Map集合
接口：：
@MapKey("id")//将查询结果的id作为大map集合的key
Map<Long,Map<String,Object>> selectAllRetMap();
xml文件：：
<select id="selectAllRetMap" resultType="map">
select * from t_student;
</select>
测试文件
Map<Long, Map<String, Object>> carMapMap = carMapper.selectAllRetMap();
Map<String, Object> car = carMapMap.get(id);
3【结果映射】
<!--专门定义一个结果映射，在这个结果映射当中指定数据库表的字段名，和java当中pojo类的属性名的关系
type：用来指定pojo类的类名
id属性，指定resultMap的唯一标识，这个id将来要在select当中使用
-->
<resultMap id="carResult" type="car">
<!--如果数据库当中有主键，建议在这里配置一个id属性，虽然不是必须的，但是可以让mybatis提高效率-->
<!--property后面填写的一般都是pojo类的属性名字
而Column一般都是写的数据库当中的列名字
-->
<id property="id" column="id"></id>
<result property="carNum" column="car_num"></result>
<result property="brand" column="brand"></result>
<result property="guidePrice" column="guide_price"></result>
<result property="produceTime" column="produce_time"></result>
<result property="carType" column="car_type"></result>
</resultMap>
<!--select的resultMap属性，写的就是我们结果映射当中配置的id-->
<select id="selectAllByResultMap" resultMap="carResult">
select * from t_car;
</select> 4【开启驼峰命名自动映射】
mybatis-config.xml文件当中
<!--放在properties文件后面-->
<settings>
<setting name="mapUnderscoreToCamelCase value="true"/>
</settings>
这个表示开启了驼峰民命自动映射，使用这个的话你的pojo类就必须按照java命名规范，首字名小写，其他大写开头
数据库的话单词与单词之间得用_分隔开
-----------------------------------------------------------------------------------
【动态sql】 mybatis-009-dynamic-sql
1.if查询
select * from t_car where 1=1
<if test="brand!=null and brand!=''">
and brand like "%"#{brand}"%"
</if>（注意，这里if当中的test标签是必须的，里面写的是bool类型true或者flase
满足，则将if标签里面的拼接到sql语句当中，不满足则不拼接,加一个1=1的原因是防止条件为空
sql语句编译错误
）
2.where查询
<select id="selectByMultiConditionWithWhere" resultType="Car">
select * from t_car
<!--where标签是专门动态生成where语句的-->
<where>
<if test="brand!=null and brand!=''">
and brand like "%"#{brand}"%"
</if>
</where>(注意 where标签可以让where子句更加的动态智能，所有条件都为空的情况不会生成
自动清除某些条件（前面）多余的and或者or 但是不能清除后面的
)
3.Trim标签
<!-- prefix：加前缀
suffix： 加后缀
prefixOverrides删除前缀
suffixOverrides删除后缀
-->
<trim prefix="where" prefixOverrides="and | or">
<if test="brand!=null and brand!=''">
and brand like "%"#{brand}"%"
</if>
4.choose,when,otherwise标签
这三个标签一般一起使用相当于if{}else if{}else{}
<where>
<choose>
<when test="brand!=null and brand!=''">brand like "%"#{brand}"%"</when>
<when test="guidePrice!=null and guidePrice!=''">guide_price > #{guidePrice}</when>
<otherwise>car_type = #{carType}</otherwise>
</choose>
</where>（就是就是如果brand为空，guideprice不为空，则跳过brand，查询guideprice）
5.foreach标签
标签当中的属性：：
collection：指定数组或者集合
item：代表数据或者集合当中的元素
separator：循环之间的分隔符
open：这个是foreach循环最前面以什么开始 反之是close
<foreach collection="ids" item="id" separator=",">
#{id}
</foreach>
6.批量插入
<insert id="insertBatch" useGeneratedKeys="true" keyProperty="id">
insert into t_car values
<foreach collection="cars" item="car" separator=",">
(null,#{car.carNum},#{car.brand},#{car.guidePrice},#{car.produceTime},#{car.carType})
</foreach>
（我们传入的是一个car类型的list集合，将car对象添加到集合当中传入进行批量添加）
熟练掌握foreach循环，可以方便我们动态使用sql语句
7.set标签
<set>
<if test="carNum!=null and carNum!=''">car_num = #{carNum},</if>
</set>
这个标签可以让我们传入car对象时执行update，对有数据的进行修改，为null的数据我们不进行修改
8.声明一个sql片段
<sql id ="">
这里写我们的sql代码
</sql>
调用sql片段
<include refid="这里写我们sql的id">
----------------------------------------------------------------------------
【高级映射机制】 mybatis-010-advanced-mapping
【多对一】
谁在前面，谁是主表，所以多对一的情况多是主表
1.第一种方式：一条sql语句，级联属性映射
<resultMap id="studentResultMap" type="student">
<id property="sid" column="sid"></id>
<result property="sname" column="sname"></result>
<result property="clazz.cid" column="cid"></result>
<result property="clazz.cname" column="cname"/>
</resultMap>
<select id="selectBySid" resultMap="studentResultMap">
select s.sid,s.sname,c.cid,c.cname
from t_stu s left join t_clazz c on s.cid = c.cid
where s.sid = #{sid};
</select>（使用多表查询，将两个表的查询结果拼接）
2.第二种方式： 一条sql语句，association
<resultMap id="studentResultMaoAssociation" type="student">
<id property="sid" column="sid"/>
<result property="sname" column="sname"/>
<association property="clazz" javaType="clazz">
<id property="cid" column="cid"/>
<result property="cname" column="cname"/>
</association>
</resultMap>
<select id="selectByIdAssociation" resultMap="">
select s.sid,s.sname,c.cid,c.cname
from t_stu s left join t_clazz c on s.cid = c.cid
where
s.sid = #{sid};
</select>（第二种方式相对于第一种方式在返回结果映射方面有所区别
使用了association）
3.第三种方式：两条sql语句
<resultMap id="selectByIdStep1ResultMap" type="student">
<id property="sid" column="sid"/>
<result property="sname" column="sname"/>
<association property="clazz"
select="com.bjpowernode.mybatis.mapper.ClazzMapper.selectByIdStep2"
（select这里面写的是你第二条sql语句的id）
column="cid"（这个column写的是你第二条sql语句需要的参数）
fetchType="lazy/>（这里的话，就是懒加载的使用 如果你只需要sname，那么它不会查询第二条语句）
(这种在association设置的fetchType只对当前的resultMap有效，局部的)
</resultMap>
<select id="selectByIdStep1" resultMap="selectByIdStep1ResultMap">
select sid,sname,cid from t_stu where sid = #{sid};
</select>
【开启全局的延迟加载】
一般只要使用分步查询，我们都开启延迟加载模式，我们开发当中一般都开启
<settings>
<setting name="lazyLoadingEnabled" value="true"/>
<!--这个是开启全局的延迟加载模式-->
</settings>
【一对多】
对比t_stu和t_clazz的话，我们需要在一的那张表 添加一个 private List<Student> stus;
<resultMap id="clazzResultMap" type="Clazz">
<id property="cid" column="cid"/>
<result property="cname" column="cname"/>
<!--一对多。collection就是集合的意思-->
<!--property属性指定clazz对象中的属性-->
<!--ofType属性用来指定集合当中的元素类型-->
<collection property="stus" ofType="Student">（一对多我们使用collection）
<id property="sid" column="sid"/>
<result property="sname" column="sname"/>
</collection>
</resultMap>
<!--Clazz selectByCollection(Integer cid);-->
<select id="selectByCollection" resultMap="clazzResultMap">
select c.cid, c.cname, s.sid, s.sname
from t_clazz c left join t_stu s on c.cid = s.cid
where c.cid = #{cid}
</select>
---------------------------------------------------------------------
【mybatis缓存机制】 mybatis-011-cache
1.一级缓存 ：：存在于SqlSession当中
什么时候缓存失效
第一次dql和第二次dql语句之间，你做了以下任意两件事当中的任意一件，都会让缓存清空
* 执行了SqlSession的clearCache（）方法 这个是手动清空缓存
* 执行了其他的insert或update或delete语句，不管是那个操作，都会清空一级缓存
2.二级缓存 ：：使用二级缓存必须满足以下4个条件
范围：：SqlSessionFactory 失效：：只要两次查询之间出现了增删改操作，二级缓存就失效了
*<setting name="cachaeEnabled" value="true">全局性开启或关闭所有映射器配置文件当中配置的任何缓存，默认是true，无需设置
*在需要使用二级缓存的时候，在sqlMapper.xml文件当中添加<cache/>
*使用二级缓存实体类必须是可序列化的，也就是必须实现java.io.Serializable接口
*SqlSession对象关闭或者提交之后，一级缓存当中的数据才会被写入二级缓存当中，此时二级缓存才可以使用
【让一个实体类可序列化】
让那个类来实现接口Serializable
比如 public class User implements Serializable{}
【使用mybatis集成EhCache】
第一步：：引入mybatis整合ehcache的依赖。
<dependency>
<groupId>org.mybatis.caches</groupId>
<artifactId>mybatis-ehcache</artifactId>
<version>1.2.3</version>
</dependency>
第二步：：在类的根路径下创建echcache.xml文件，并且提供以下配置文件
------------------------------------------------------
【分页查询】
limit ：
select * from t_car limit 0,2;（这个是从下标0开始，查询两条数据）
pageSize（每页显示条数） pageNum（页码）
起始下标： startIndex = （pageNum-1）* pageSize ；
【mybatis使用PageHelper】
第一步：引入依赖
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>5.3.2</version>
</dependency>
第二步：在mybatis-config.xml文件当中配置插件
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>
第三步： 在执行dql语句之前执行PageHelper,开启分页查询
PageHelper.startPage(2,3);（这个是开启分页查询，从坐标为2开始查询，查询三个）
List<Car> cars = carMapper.selectByPageHelper();
【逆向工程】
1.配置mybatis逆向工程插件
<!--定制构建过程-->
<build>
<!--可配置多个插件-->
<plugins>
<!--其中的⼀个插件：mybatis逆向⼯程插件-->
<plugin>
<!--插件的GAV坐标-->
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-maven-plugin</artifactId>
<version>1.4.1</version>
<!--允许覆盖-->
<configuration>
<overwrite>true</overwrite>
</configuration>
<!--插件的依赖-->
<dependencies>
<!--mysql驱动依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.30</version>
</dependency>
</dependencies>
</plugin>
</plugins>
</build>
<!--定制构建过程-->
<build>
<!--可配置多个插件-->
<plugins>
<!--其中的⼀个插件：mybatis逆向⼯程插件-->
<plugin>
<!--插件的GAV坐标-->
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-maven-plugin</artifactId>
<version>1.4.1</version>
<!--允许覆盖-->
<configuration>
<overwrite>true</overwrite>
</configuration>
<!--插件的依赖-->
<dependencies>
<!--mysql驱动依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.30</version>
</dependency>
</dependencies>
</plugin>
</plugins>
</build>
第二步：：在类的根路径下创建generatorConfig.xml文件 ，记住，这个文件的名字不能更改，只能是这个
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
"http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
<!--
targetRuntime有两个值：
MyBatis3Simple：⽣成的是基础版，只有基本的增删改查。
MyBatis3：⽣成的是增强版，除了基本的增删改查之外还有复杂的增删改查。
-->
<context id="DB2Tables" targetRuntime="MyBatis3Simple">
<!--防⽌⽣成重复代码-->
<plugin type="org.mybatis.generator.plugins.UnmergeableXmlMappersPlugin"/>
<commentGenerator>
<!--是否去掉⽣成⽇期-->
<property name="suppressDate" value="true"/>
<!--是否去除注释-->
<property name="suppressAllComments" value="true"/>
</commentGenerator>
<!--连接数据库信息-->
<jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
connectionURL="jdbc:mysql://localhost:3306/mvc"
userId="root"
password="Xx20011128">
</jdbcConnection>
<!-- ⽣成pojo包名和位置 -->
<javaModelGenerator targetPackage="com.bjpowernode.mybatis.pojo" targetProject="src/main/java">
<!--是否开启⼦包-->
<property name="enableSubPackages" value="true"/>
<!--是否去除字段名的前后空⽩-->
<property name="trimStrings" value="true"/>
</javaModelGenerator>
<!-- ⽣成SQL映射⽂件的包名和位置 -->
<sqlMapGenerator targetPackage="com.bjpowernode.mybatis.mapper" targetProject="src/main/resources">
<!--是否开启⼦包-->
<property name="enableSubPackages" value="true"/>
</sqlMapGenerator>
<!-- ⽣成Mapper接⼝的包名和位置 -->
<javaClientGenerator
type="xmlMapper"
targetPackage="com.bjpowernode.mybatis.mapper"
targetProject="src/main/java">
<property name="enableSubPackages" value="true"/>
</javaClientGenerator>
<!-- 表名和对应的实体类名-->
<table tableName="t_car" domainObjectName="Car"/>
</context>
</generatorConfiguration>
第三步：更改generatorConfig.xml文件当中创建包的位置
以及配置mybatis框架jar包依赖，配置文件等
mybatis-config主配置文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!--直接将我们的配置文件放进来-->
<properties resource="jdbc.properties"/>
<settings>
<!--开启驼峰自动命名-->
<setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
<typeAliases>
<!--将我们所需要起别名的pojo包名放进来，就会帮我们全部取别名，默认就是类名-->
<package name="com.bjpowernode.mybatis.pojo"/>
</typeAliases>
<!--这个是我们默认使用的环境-->
<environments default="dev">
<environment id="dev">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</dataSource>
</environment>
</environments>
<mappers>
<package name=""/>这里写的是我们配置sqlMapper.xml文件
可以直接在这里将mapper接口的全路径放过来 也可以在下面mapper哪里直接配置
<mapper resource=""></mapper> 这里使用的是resource，是从类的根路径下开始寻找
</mappers>
</configuration>logback文件
<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="false">
<!--定义⽇志⽂件的存储地址-->
<property name="LOG_HOME" value="/home"/>
<!-- 控制台输出 -->
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
<!--格式化输出：%d表示⽇期，%thread表示线程名，%-5level：级别从左显示5个字符宽度%msg：⽇志消息，%n是换⾏符-->
<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
</encoder>
</appender>
<!--mybatis log configure-->
<logger name="com.apache.ibatis" level="TRACE"/>
<logger name="java.sql.Connection" level="DEBUG"/>
<logger name="java.sql.Statement" level="DEBUG"/>
<logger name="java.sql.PreparedStatement" level="DEBUG"/>
<!-- ⽇志输出级别,logback⽇志级别包括五个：TRACE < DEBUG < INFO < WARN < ERROR -->
<root level="DEBUG">
<appender-ref ref="STDOUT"/>
<appender-ref ref="FILE"/>
</root>
</configuration>
1254
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
