环境:
回顾:
SSM框架:配置文件的。最好的方式:看官网文档;
mybatis – MyBatis 3 | 入门
如何获得Mybatis?
maven仓库:
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.5.3version>
dependency>
.Github :Releases · mybatis/mybatis-3 · GitHub
中文文档 :mybatis – MyBatis 3 | 入门
数据持久化
为什么需要需要持久化?
Dao层,Service层,Controller层…
·优点:
最重要的一点:使用的人多!
思路:搭建环境–>导入Mybatis–>编写代码–>测试!
搭建数据库
CREATE DATABASE `mybatis`;
USE `mybatis`;
CREATE TABLE `user`(
`id` INT(20) NOT NULL PRIMARY KEY,
`name` VARCHAR(30) DEFAULT NULL,
`pwd` VARCHAR(30) DEFAULT NULL
)ENGINE=INNODB DEFAULT CHARSET=utf8;
INSERT INTO `user`(`id`,`name`,`pwd`) VALUES
(1,'王海林','123456') ,
(2,'海林','124446') ,
(3,'王林','122256') ,
(4,'王海','123456')
新建项目
1.新建一个普通的maven项目
2.删除src目录
3.导入maven依赖
<dependencies>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>5.1.47version>
dependency>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.5.3version>
dependency>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.13version>
<scope>testscope>
dependency>
dependencies>
在mybatis-config.xml 中 编写mybatis的核心配置文件
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/smbms?useSSL=false&useUnicode=true&characterEncoding=utf-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
dataSource>
environment>
environments>
<mappers>
<mapper resource="org/mybatis/example/BlogMapper.xml"/>
mappers>
configuration>
package com.Wang.utils;
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 java.io.IOException;
import java.io.InputStream;
//工具类 用来获取sqlSessionFactory的对象 --用来生产--》 sqlSession
public class MybatisUtils {
private static SqlSessionFactory sqlSessionFactory;
static {
//使用Mybatis的第一步 ——————》获取sqlSessionFactory的对象
try {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
} catch (IOException e) {
e.printStackTrace();
}
}
//既然有了 SqlSessionFactory,顾名思义,我们可以从中获得 SqlSession 的实例。
// SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
public static SqlSession getSqlSession(){
return sqlSessionFactory.openSession();
}
}
package com.Wang.pojo;
public class User {
private int id;
private String name;
private String pwd;
public User() {
}
public User(int id, String name, String pwd) {
this.id = id;
this.name = name;
this.pwd = pwd;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPwd() {
return pwd;
}
public void setPwd(String pwd) {
this.pwd = pwd;
}
@Override
public String toString() {
return "com.Wang.pojo.User{" +
"id=" + id +
", name='" + name + '\'' +
", pwd='" + pwd + '\'' +
'}';
}
}
package com.Wang.mapper;
import com.Wang.pojo.User;
import java.util.List;
public interface UserMapper {
List<User> getUserList();
}
<mapper namespace="com.Wang.mapper.UserMapper">//所要连接的接口
//select为查询的语句,id连接所要实现的方法,resultType为返回的类型
<select id="getUserList" resultType="com.Wang.pojo.User">
select * from mybatis.user
select>
mapper>
parameterType:指定输入参数类型,mybatis通过ognl从输入对象中获取参数值拼接在sql中。
resultType:指定输出结果类型,mybatis将sql查询结果的一行记录数据映射为resultType指定类型的对象。如果有多条数据,则分别进行映射,并把对象放到容器List中
注意点:
org.apache.ibatis.binding.BindingExcepion: ype TmelIatecInuutguUMapperRegistry.
MapperRegistry是什么?
这里可能会出现一个错误:
这是因为Maven中的配置出现了错误,需要加上:
<build>
<resources>
<resource>
<directory>src/main/resourcesdirectory>
<includes>
<include>**/*.propertiesinclude>
<include>**/*.xmlinclude>
includes>
resource>
<resource>
<directory>src/main/javadirectory>
<includes>
<include>**/*.propertiesinclude>
<include>**/*.xmlinclude>
includes>
<filtering>truefiltering>
resource>
resources>
build>
package com.Wang.mapper;
import com.Wang.pojo.User;
import com.Wang.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;
public class UserMapperTest {
@Test
public void test(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List userList = mapper.getUserList();
for (User user: userList) {
System.out.println(user);
}
sqlSession.close();
}
}
测试成功!
namespace中的包名要和Dao/mapper接口的包名一致!
选择,查询语句;
1.编写接口
//查询全部用户消息
List getUserList();
//根据用户id查询
User getUserById(int id);
//insert用户
int insertUser(User user);
//delete user
int deleteUser(int id);
//update user
int updateUser(User id);
2.编写对应的mapper中的sql语句
<mapper namespace="com.Wang.mapper.UserMapper">
<select id="getUserList" resultType="com.Wang.pojo.User">
select * from mybatis.user
select>
<select id="getUserById" parameterType="int" resultType="com.Wang.pojo.User">
select * from mybatis.user where id = #{id}
select>
<insert id="insertUser" parameterType="com.Wang.pojo.User">
insert into mybatis.user(id,name,pwd) value (#{id},#{name},#{pwd})
insert>
<delete id="deleteUser" parameterType="int">
delete from mybatis.user where id = #{id}
delete>
<update id="updateUser" parameterType="com.Wang.pojo.User">
update mybatis.user set name = #{name},pwd = #{pwd} where id = #{id}
update>
mapper>
3.测试
package com.Wang.mapper;
import com.Wang.pojo.User;
import com.Wang.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;
public class UserMapperTest {
@Test
public void test(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> userList = mapper.getUserList();
for (User user: userList) {
System.out.println(user);
}
sqlSession.close();
}
@Test
public void getUserById(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User user = mapper.getUserById(1);
System.out.println(user);
sqlSession.close();
}
@Test
public void insertUser(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int zj = mapper.insertUser(new User(5, "周洁", "123453"));
if (zj>0){
System.out.println("插入成功!");
}
sqlSession.commit();
sqlSession.close();
}
@Test
public void deleteUser(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int i = mapper.deleteUser(4);
if (i>0){
System.out.println(":success");
}
sqlSession.commit();
sqlSession.close();
}
@Test
public void updateUser(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int i = mapper.updateUser(new User(2, "哈哈哈", "11111"));
if (i>0){
System.out.println("success");
}
sqlSession.commit();
sqlSession.close();
}
}
<insert id="insertUser" parameterType="com.Wang.pojo.User">
insert into mybatis.user(id,name,pwd) value (#{id},#{name},#{pwd})
insert>
<update id="updateUser" parameterType="com.Wang.pojo.User">
update mybatis.user set name = #{name},pwd = #{pwd} where id = #{id}
update>
<delete id="deleteUser" parameterType="int">
delete from mybatis.user where id = #{id}
delete>
注意点:
增删改需要提交事务!
假设,我们的实体类,或者数据库中的表,字段或者参数过多,我们应当考虑使用Map!
//万能的map
int addUser(HashMap<String,Object> map);
<insert id="addUser" parameterType="map">
insert into mybatis.user(id,name,pwd) value (#{userId},#{userName},#{Password})
insert>
@Test
public void addUser(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
HashMap<String, Object> map = new HashMap<>();
map.put("userId",6);
map.put("userName","周小洁");
map.put("Password","1122222");
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
mapper.addUser(map);
sqlSession.commit();
sqlSession.close();
}
Map传递参数,直接在sql中取出key即可! 【parameterType=“map”】
对象传递参数,直接在sql中取对象的属性即可! 【parameterType=“Object”】
只有一个基本类型参数的情况下,可以直接在sql中取到!
多个参数用Map,或者注解!
模糊查询怎么写?
1.Java代码执行的时候,传递通配符 % %
List<user> userList = mapper.getuserLike("%李%");
2.在sql拼接中使用通配符!
select * from mybatis.user where name like "%"#{value}"%"
configuration(配置)
properties(属性)
settings(设置)
typeAliases(类型别名)
typeHandlers(类型处理器)
objectFactory(对象工厂)
plugins(插件)
environments(环境配置)
environment(环境变量)
transactionManager(事务管理器)
dataSource(数据源)
databaseIdProvider(数据库厂商标识)
mappers(映射器)
MyBatis 可以配置成适应多种环境
不过要记住:尽管可以配置多个环境,但每个 SqlSessionFactory 实例只能选择一种环境。
学会使用配置多套运行环境!
Mybatis默认的事务管理器就是JDBC,连接池:POOLED
environments 元素定义了如何配置环境。
<environments default="development"> //这里default来设置默认的配置环境
<environment id="development">
<transactionManager type="JDBC">
<property name="..." value="..."/>
transactionManager>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
dataSource>
environment>
environments>
注意一些关键点:
默认环境和环境 ID 顾名思义。 环境可以随意命名,但务必保证默认的环境 ID 要匹配其中一个环境 ID。
我们可以通过properties属性来实现引用配置文件
这些属性都是可外部配置且可动态替换的,既可以在典型的Java属性文件中配置,
亦可通过properties元素的子元素来传递。【db.properties】
编写一个配置文件
db.properties
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&useUnicode=true&characterEncoding=utf-8
username=root
password=123456
在核心配置文件中引入
<properties resource="db.properties">
<property name="" value=""/>//在这里也可以设置配置文件
<property name="" value=""/>
properties>
<typeAliases>
<typeAlias type="com.Wang.pojo.User" alias="User"/>
typeAliases>
也可以指定一个包名,MyBatis 会在包名下面搜索需要的Java Bean,比如:
扫描实体类的包,它的默认别名就为这个类的类名,首字母小写!
<typeAliases>
<package name="com.Wang.pojo"/>
typeAliases>
在实体类比较少的时候,使用第一种方式。
如果实体类十分多,建议使用第二种。
第一种可以DIY别名,第二种则**·不行·,如果非要改,需要在实体上增加注解**
import org.apache.ibatis.type.Alias;
@Alias("hello")
public class User {
这是 MyBatis 中极为重要的调整设置,它们会改变 MyBatis 的运行时行为。
设置名 | 描述 | 有效值 | 默认值 |
---|---|---|---|
cacheEnabled | 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。 | true | false | true |
lazyLoadingEnabled | 延迟加载的全局开关。当开启时,所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。 |
true | false | false |
mapUnderscoreToCamelCase | 是否开启驼峰命名自动映射,即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。 | true | false | False |
---|---|---|---|
MapperRegistry: 注册绑定我们的Mapper文件;
方式一:
<mappers>
<mapper resource="com/Wang/mapper/UserMapper.xml"/>
mappers>
方式二:使用class文件绑定注册
<mappers>
<mapper class="com.Wang.mapper.UserMapper"/>
mappers>
**注意点:**在使用包,与class扫描的时候:
方式三:使用扫描包进行注入绑定
<mappers>
<package name="com.Wang.mapper"/>
mappers>
**注意点:**在使用包,与class扫描的时候:
生命周期,和作用域,是至关重要的,因为错误的使用会导致非常严重的并发问题。
这里面的每一个Mapper,就代表一个具体的业务!
数据库中的字段
新建一个项目,拷贝之前的,测试实体类字段不一致的情况
public class User {
private int id;
private String name;
private String password;
}
测试出现问题:
分析原因:
select * from mybatis.user where id = #{id}
//类型处理器 *被转义为id,name,pwd
select id,name,pwd from mybatis.user where id = #{id}
解决方法:
select id,name,pwd as password from mybatis.user where id = #{id}
数据库中: id name pwd
实体类中: id name password
<resultMap id="UserMap" type="User">
<result column="id" property="id">result>
<result column="name" property="name">result>
<result column="pwd" property="password">result>
resultMap>
<select id="getUserById" resultMap="UserMap">
select * from mybatis.user where id = #{id}
select>
如果一个数据库操作,出现了异常,我们需要排错。日志就是最好的助手!
曾经:sout . debug
现在:日志工厂!
logImpl | 指定 MyBatis 所用日志的具体实现,未指定时将自动查找。 | SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING | 未设置 |
---|---|---|---|
在Mybatis中具体使用那个一日志实现,在设置中设定!
在mybatis核心配置文件中,配置我们的日志!
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
settings>
什么是Log4j?
<dependencies>
<dependency>
<groupId>log4jgroupId>
<artifactId>log4jartifactId>
<version>1.2.12version>
dependency>
dependencies>
#将等级为DEBUG的日志信息输出到console和file这两个目的地,console和file的定义在下面的代码
log4j.rootLogger=DEBUG,console,file
#控制台输出的相关设置
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n
#文件输出的相关设置
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./log/Wang.log
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n
#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG
<settings>
<setting name="logImpl" value="log4j"/>
settings>
简单使用
1.在要使用Log4j的类中,导入包
import org.apache.log4j.Logger;
2.日志对象,参数为当前类的class
static Logger logger = Logger.getLogger(UserMapperTest.class);
3.日志级别
logger.info("info:");
logger.debug("debug:");
logger.error("error:");
思考:为什么要分页?
语法: select * from mybatis.user limit startIndex,pageSize;
select * from mybatis.user limit 3; 【起始页,页面大小】
使用Mybatis实现分页,核心SQL
1.接口
//分页查询
List<User> getUserLimit(Map<String,Integer> map);
2.Mapper.xml
<resultMap id="UserMap" type="User"/>
<select id="getUserLimit" resultMap="UserMap">
select * from mybatis.user limit #{startIndex},#{pageSize}
select>
3.测试
@Test
public void TestUserLimit(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
HashMap<String, Integer> map = new HashMap<>();
map.put("startIndex",1);
map.put("pageSize",3);
List<User> userLimit = mapper.getUserLimit(map);
for (User user : userLimit) {
System.out.println(user);
}
sqlSession.commit();
sqlSession.close();
}
不再使用SQL实现分页
1.接口
//rowBounds分页
List<User> getUserRowBounds();
2.mapper.xml
<select id="getUserRowBounds" resultMap="UserMap">
select * from mybatis.user
select>
3.测试
@Test
public void getUserRowBounds(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
RowBounds rowBounds = new RowBounds(1, 2);
List<User> mapper = sqlSession.selectList("com.Wang.mapper.UserMapper.getUserRowBounds",null,rowBounds);
for (User user : mapper) {
System.out.println(user);
}
sqlSession.commit();
sqlSession.close();
}
PageHelper
了解即可,万一以后公司的架构师,说要使用,你需要知道它是什么东西!
关于接口的理解
三个面向区别
-面向对象是指,我们考虑问题时,以对象为单位,考虑它的属性及方法.
-面向过程是指,我们考虑问题时,以一个具体的流程(事务过程)为单位,考虑它的实现.
-接口设计与非接口设计是针对复用技术而言的,与面向对象(过程)不是一个问题.更多的体现就是对系统整体的架构
1.注解在接口上实现
@Select("select * from mybatis.user")
List<User> getUsers();
2.需要再核心配置文件中绑定接口!
//绑定接口
<mappers>
<mapper class="com.Wang.mapper.UserMapper"/>
mappers>
3.测试
@Test
public void getUsers(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> users = mapper.getUsers();
for (User user : users) {
System.out.println(user);
}
sqlSession.commit();
sqlSession.close();
}
本质:反射机制
实现底层:动态代理!
我们可以在工具类创建的时候实现自动提交事务!
package com.Wang.utils;
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 java.io.IOException;
import java.io.InputStream;
//工具类 用来获取sqlSessionFactory的对象 --用来生产--》 sqlSession
public class MybatisUtils {
private static SqlSessionFactory sqlSessionFactory;
static {
//使用Mybatis的第一步 ——————》获取sqlSessionFactory的对象
try {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
} catch (IOException e) {
e.printStackTrace();
}
}
//既然有了 SqlSessionFactory,顾名思义,我们可以从中获得 SqlSession 的实例。
// SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。
public static SqlSession getSqlSession(){
//设置自动提交
return sqlSessionFactory.openSession(true);
}
}
编写接口,增加注解
package com.Wang.mapper;
import com.Wang.pojo.User;
import org.apache.ibatis.annotations.*;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public interface UserMapper {
@Select("select * from mybatis.user")
List getUsers();
@Select("select * from mybatis.user where id = #{uid}")
User getUserById(@Param("uid") int id);
@Insert("insert into mybatis.user(id, name, pwd) VALUE (#{id},#{name},#{pwd})")
int addUser(User user);
@Update("update mybatis.user set name = #{name}, pwd = #{pwd} where id = #{id}")
int updateUser(User user);
@Delete("delete from mybatis.user where id = #{uid}")
int deleteUser(@Param("uid") int id);
}
测试类
package com.Wang.mapper;
import com.Wang.pojo.User;
import com.Wang.utils.MybatisUtils;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.HashMap;
import java.util.List;
public class UserMapperTest {
@Test
public void deleteUser(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int i = mapper.deleteUser(7);
if (i>0){
System.out.println("ok");
}
sqlSession.close();
}
@Test
public void updateUser(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int 周小洁 = mapper.updateUser(new User(7, "周小洁", "000000"));
if (周小洁>0){
System.out.println("ok");
}
sqlSession.close();
}
@Test
public void addUser(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
int user = mapper.addUser(new User(7, "哈哈哈", "111111"));
if (user>0){
System.out.println("ok");
}
sqlSession.close();
}
@Test
public void getUserById(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
User userById = mapper.getUserById(1);
System.out.println(userById);
sqlSession.close();
}
@Test
public void getUsers(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> users = mapper.getUsers();
for (User user : users) {
System.out.println(user);
}
sqlSession.commit();
sqlSession.close();
}
}
【注意:我们必须要讲接口注册绑定到我们的核心配置文件中!】
<mappers>
<mapper class="com.Wang.mapper.UserMapper"/>
mappers>
关于@Param()注解
- ***#{}* 对应的变量*会*自动加上*单引号*
- ***${}* 对应的变量*不会*加上*单引号*
- ***#{}* *能*防止sql 注入
- ***${}* *不能*防止sql 注入
- *#{}* 默认值 *arg0*、*arg1*、*arg2 或 0、 1*
- *${}* 默认值*param1*、*param2*、*param3*
能用 #{} 的地方就用 #{},尽量少用 ${}
表名作参数,或者order by 排序时用 ${}
传参时参数使用@Param("")注解,@Param注解的作用是给参数命名,参数命名后就能根据名字得到参数值(相当于又加了一层密),正确的将参数传入sql语句中(一般通过#{}的方式,${}会有sql注入的问题)。如下:
Role selectById(@Param("id") String id);
List<Role> selectByNameAndOrgId(@Param("name") String name, @Param("orgId") String orgId);
Lombok是一款Java开发插件,使得Java开发者可以通过其定义的一些注解来消除业务工程中冗长和繁琐的代码,尤其对于简单的Java模型对象(POJO)。在开发环境中使用Lombok插件后,Java开发人员可以节省出重复构建,诸如hashCode和equals这样的方法以及各种业务对象模型的accessor和ToString等方法的大量时间。对于这些方法,它能够在编译源代码期间自动帮我们生成这些方法,并没有如反射那样降低程序的性能。
<dependencies>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<version>1.18.20version>
dependency>
dependencies>
@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
@val
@var
experimental @var
@UtilityClass
Lombok config system
Code inspections
Refactoring actions (lombok and delombok)
@Data: 参构造,get、set、tostring、hashcode,equals
@AllArgsConstructor //有参构造
@NoArgsConstructor //无参构造
Lombok常用注解说明
.@NonNull;用在方法参数前,会自动对该参数进行非空校验,为空抛出NPE (NullPointerException)
.@Cleanup:自动管理资源,用在局部变量之前,在当前变量范围内即将执行完毕退出前会清理资源,生成try-finally的代码关闭流. @Getterl@Setter:用在属性上,不用自己手写setter和getter方法,还可指定访问范围
. @ToString:用在类上,可以自动覆写toString方法
@EqualsAndHashCode:用在类上,自动生成equals方法和hashCode方法
·@NoArgsConstructor.@RequiredArgsConstructor and @aAllArgsConstructor:用在类上,自动生成无参构造和使用所有参数的有参构造函数。·@ata:用在类上,相当于同时使用了@ToString、@EqualsAndHashCode、@Geter、@Setter和@RequiredArgsConstrutor这些注解,对POJO类十分有用
. @Value:用在类上,是@Data的不可变形式,相当于为属性添加final声明,只提供getter方法,而不提供setter方法· @SneakyThrows:自动抛受检异常,而无需显式在方法上使用throws语句
. @Synchronized:用在方法上,将方法声明为同步的,并自动加锁
. @Getter(lazy=true):可以替代经典的Double Check Lock样板代码
@Data
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode
@Getter
@Setter
@ToString
优点:
1.能通过注解的形式自动生成构造器、getter/setter、equals、hashcode、toString等方法,提高了一定的开发效率
2.让代码变得简洁,不用过多的去关注相应的方法
3.属性做修改时,也简化了维护为这些属性所生成的getter/setter方法等
缺点:
1.不支持多种参数构造器的重载
2.虽然省去了手动创建getter/setter方法的麻烦,但大大降低了源代码的可读性和完整性,降低了阅读源代码的舒适度
Lombok虽然有很多优点,但Lombok更类似于一种IDE插件,项目也需要依赖相应的jar包。Lombok依赖jar包是因为编译时要用它的注解,为什么说它又类似插件?因为在使用时,eclipse或Intelli] IDEA都需要安装相应的插件,在编译器编译时通过操作AST(抽象语法树)改变字节码生成,变向的就是说它在改变java语法。
它不像spring的依赖注入或者mybatis的ORM—样是运行时的特性,而是编译时的特性。这里我个人最感觉不爽的地方就是对插件的依赖!因为Lombok只是省去了一些人工生成代码的麻烦,但IDE都有快捷键来协助生成getter/setter等方法,也非常方便。
知乎上有位大神发表过对Lombok的一些看法:
这是一种低级趣味的插件,不建议使用。JAVa发展到今天,各种插件层出不穷,如何甄别各种插件的优劣?能从架构上优化你的设计的,能提高应用程序性能的,实现高度封装可扩展的…,像lombok这种,像这种插件,已经不仅仅是插件了,改变了你如何编写源码,事实上,少去了的代码,你写上去又如何?如果JAvA家族到处充斥这样的东西,那只不过是一坨披着金属颜色的屎,迟早会被其它的语言取代。
虽然话糙但理确实不糙,试想一个项目有非常多类似Lombok这样的插件,个人觉得真的会极大的降低阅读源代码的舒适度。虽然非常不建议在属性的getter/setter写一些业务代码,但在多年项目的实战中,有时通过给getter/setter加一点点业务代码,能极大的简化某些业务场景的代码。所谓取舍,也许就是这时的舍弃一定的规范,取得极大的方便。
我现在非常坚信一条理念,任何编程语言或插件,都仅仅只是工具而已,即使工具再强大也在于用的人,就如同小米加步枪照样能赢飞机大炮的道理一样。结合具体业务场景和项目实际情况,无需一味追求高大上的技术,适合的才是王道。
Lombok有它的得天独厚的优点,也有它避之不及的缺点,熟知其优缺点,在实战中灵活运用才是王道。
CREATE TABLE `teacher` (
`id` INT(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO teacher(`id`, `name`) VALUES (1, '秦老师');
CREATE TABLE `student` (
`id` INT(10) NOT NULL,
`name` VARCHAR(30) DEFAULT NULL,
`tid` INT(10) DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `fktid` (`tid`),
CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8
INSERT INTO student(`id`, `name`, `tid`) VALUES ('1', '小明', '1');
INSERT INTO student(`id`, `name`, `tid`) VALUES ('2', '小红', '1');
INSERT INTO student(`id`, `name`, `tid`) VALUES ('3', '小张', '1');
INSERT INTO student(`id`, `name`, `tid`) VALUES ('4', '小李', '1');
INSERT INTO student(`id`, `name`, `tid`) VALUES ('5', '小王', '1');
1.导入lombok
⒉.新建实体类Teacher,Student3.建立Mapper接口
4.建立Mapper.XML文件
5.在核心配置文件中绑定注册我们的Mapper接口或者文件!【方式很多,随心选】
6.测试查询是否能够成功!
<mapper namespace="com.Wang.mapper.StudentMapper">
<select id="getStudent" resultMap="StudentTeacher">
select * from student
select>
<resultMap id="StudentTeacher" type="Student">
<result property="id" column="id">result>
<result property="name" column="name">result>
<association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
resultMap>
<select id="getTeacher" resultType="Teacher">
select * from mybatis.teacher where id = #{id}
select>
mapper>
<select id="getStudent2" resultMap="StudentTeacher2">
select s.id sid,s.name sname,t.name tname
from mybatis.student s,mybatis.teacher t
where s.tid = t.id
select>
<resultMap id="StudentTeacher2" type="Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<association property="teacher" javaType="Teacher">
<result property="name" column="tname"/>
association>
resultMap>
回顾Mysql多对一查询方式:
比如:一个老师拥有多个学生!对于老师而言,就是一对多的关系!
实体类
package com.Wang.pojo;
import lombok.Data;
@Data
public class Student {
private int id;
private String name;
private int tid;
}
package com.Wang.pojo;
import lombok.Data;
import java.util.List;
@Data
public class Teacher {
private int id;
private String name;
//一个老师对应多个学生
private List<Student> students;
}
<mapper namespace="com.Wang.mapper.TeacherMapper">
<select id="getTeacher" resultMap="StudentTeacher">
select s.id sid, s.name sname, t.id tid, t.name tname
from mybatis.teacher t,mybatis.student s
where s.tid = t.id and t.id = #{tid}
select>
<resultMap id="StudentTeacher" type="Teacher">
<result property="id" column="tid"/>
<result property="name" column="tname"/>
<collection property="students" ofType="Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<result property="tid" column="tid"/>
collection>
resultMap>
mapper>
1.关联- association【多对一】
2.集合- collection【一对多】
javaType & ofType
1.JavaType用来指定实体类中属性的类型
2.ofType 用来指定映射到List或者集合中的pojo类型,泛型中的约束类型!
注意点:
· 保证SQL的可读性,尽量保证通俗易懂
·注意一对多和多对一中,属性名和字段的问题!
·如果问题不好排查错误,可以使用日志,建议使用Log4j
慢SQL 1s 1000s
面试高频
· Mysql引擎
. lnnoDB底层原理
·索引
·索引优化!
什么是动态SQL:动态SQL就是指根据不同的条件生成不同的SQL语句利用动态SQL这一特性可以彻底摆脱这种痛苦。
动态 sQL元素和JSTL或基于类似XML的文本处理器相似。
在MyBatis之前的版本中,有很多元素需要花时间了解。
MyBatis 3大大精简了元素种类,现在只需学习原来一半的元素便可。
MyBatis采用功能强大的基于OGNL的表达式来淘汰其它大部分元素。
if
choose (when,otherwise)
trim (where,set)
foreach
CREATE TABLE `blog`(
`id` VARCHAR(50) NOT NULL COMMENT '博客id',
`title` VARCHAR(100) NOT NULL COMMENT '博客标题',
`author` VARCHAR(30) NOT NULL COMMENT '博客作者',
`create_time` DATETIME NOT NULL COMMENT '创建时间',
`views` INT(30) NOT NULL COMMENT '浏览量'
)ENGINE=INNODB DEFAULT CHARSET=utf8
1.导包
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>mybatis-studyartifactId>
<groupId>com.WanggroupId>
<version>1.0-SNAPSHOTversion>
parent>
<modelVersion>4.0.0modelVersion>
<artifactId>mybatis-demo08artifactId>
<dependencies>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<version>1.18.20version>
dependency>
<dependency>
<groupId>org.junit.jupitergroupId>
<artifactId>junit-jupiterartifactId>
<version>RELEASEversion>
<scope>compilescope>
dependency>
dependencies>
<build>
<resources>
<resource>
<directory>src/main/resourcesdirectory>
<includes>
<include>**/*.propertiesinclude>
<include>**/*.xmlinclude>
includes>
resource>
<resource>
<directory>src/main/javadirectory>
<includes>
<include>**/*.propertiesinclude>
<include>**/*.xmlinclude>
includes>
<filtering>truefiltering>
resource>
resources>
build>
project>
2.编写配置文件
<configuration>
<properties resource="db.properties">
properties>
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
<setting name="mapUnderscoreToCamelCase" value="true"/>
settings>
<typeAliases>
<package name="com.Wang.pojo"/>
typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
dataSource>
environment>
environments>
<mappers>
<mapper class="com.Wang.mapper.BlogMapper"/>
mappers>
configuration>
<configuration>
<properties resource="db.properties">
properties>
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
<setting name="mapUnderscoreToCamelCase" value="true"/>
settings>
<typeAliases>
<package name="com.Wang.pojo"/>
typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="${driver}"/>
<property name="url" value="${url}"/>
<property name="username" value="${username}"/>
<property name="password" value="${password}"/>
dataSource>
environment>
environments>
<mappers>
<mapper class="com.Wang.mapper.BlogMapper"/>
mappers>
configuration>
3.编写实体类
package com.Wang.pojo;
import lombok.Data;
import java.util.Date;
@Data
public class Blog {
private String id;
private String title;
private String author;
private Date createTime;
private int views;
}
UUID的使用
package com.Wang.utils;
import org.junit.jupiter.api.Test;
import java.util.UUID;
public class IdUtils {
public static String getId(){
return UUID.randomUUID().toString().replaceAll("-","");
}
@Test
public void test(){
System.out.println(IdUtils.getId());
System.out.println(IdUtils.getId());
System.out.println(IdUtils.getId());
System.out.println(IdUtils.getId());
}
}
4.编写实体类对应Mapper接口和Mapper.XML文件
package com.Wang.mapper;
import com.Wang.pojo.Blog;
public interface BlogMapper {
int addBlog(Blog blog);
}
<mapper namespace="com.Wang.mapper.BlogMapper">
<insert id="addBlog" parameterType="blog">
insert into mybatis.blog (id,title,author,create_time,views)
value (#{id},#{title},#{author},#{createTime},#{views});
insert>
mapper>
<select id="queryBlog" parameterType="map" resultType="Blog">
select * from mybatis.blog where 1=1
<if test="title != null">
and title = #{title}
if>
<if test="author != null">
and author = #{author}
if>
select>
if代码优化
<select id="queryBlog" parameterType="map" resultType="Blog">
select * from mybatis.blog
<where>
<if test="title != null">
title = #{title}
if>
<if test="author != null">
and author = #{author}
if>
where>
select>
从多个条件中选择一个使用
<select id="queryBlogChoose" parameterType="map" resultType="blog">
select * from mybatis.blog
<where>
<choose>
<when test="id != null">
id = #{id}
when>
<when test="title != null">
title = #{title}
when>
<when test="author != null">
author = #{author}
when>
<otherwise>
1=1
otherwise>
choose>
where>
select>
where的使用
where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句。而且,若子句的开头为 “AND” 或 “OR”,where 元素也会将它们去除。
<select id="queryBlog" parameterType="map" resultType="Blog">
select * from mybatis.blog
<where>
<if test="title != null">
title = #{title}
if>
<if test="author != null">
and author = #{author}
if>
where>
select>
set的使用
set 元素会动态地在行首插入 SET 关键字,并会删掉额外的逗号(这些逗号是在使用条件语句给列赋值时引入的)
<update id="updateBlog" parameterType="Blog">
update mybatis.blog
<set>
<if test="id != null">id = #{id},if>
<if test="title != null">title = #{title},if>
<if test="author != null">author = #{author}if>
set>
where views = #{views}
update>
所谓的动态SQL,本质还是SQL语句,只是我们可以在SQL层面,去执行一个逻辑代码
if
where , set , choose , when
有的时候,我们可能会将一些功能的部分抽取出来,方便复用
<sql id="id-title-author">
<if test="title != null">
title = #{title}
if>
<if test="author != null">
and author = #{author}
if>
sql>
<select id="queryBlog" parameterType="map" resultType="Blog">
select * from mybatis.blog
<where>
<include refid="id-title-author">include>
where>
select>
注意事项:
<select id="queryBlogForeach" parameterType="map" resultType="blog">
select * from mybatis.blog
<where>
<foreach collection="ids" item="id" open="and (" close=")" separator="or">
id = #{id}
foreach>
where>
select>
测试:
@Test
public void queryBlogForeach(){
SqlSession sqlSession = MybatisUtils.getSqlSession();
BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
HashMap hashMap = new HashMap();
ArrayList list = new ArrayList();
list.add(1);
list.add(3);
list.add(3);
hashMap.put("ids",list);
List<Blog> blogs = mapper.queryBlogForeach(hashMap);
for (Blog blog : blogs) {
System.out.println(blog);
}
sqlSession.close();
}
动态SQL就是在拼接SQL语句,我们只要保证SQL的正确性,按照SQL的格式,去排列组合就可以了
建议:
查询: 连接数据库, 耗资源!
一次查询的结果,给他暂存在一个可以直接取到的地方!-->内存:缓存
我们再次查询相同数据的时候,直接走缓存,就不用走数据库了
MyBatis包含一个非常强大的查询缓存特性,它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
一级缓存也叫本地缓存:
1.开启日志!
⒉.测试在一个Sesion中查询两次相同记录
3.查看日志输出
1.查询不同的东西
2.增删改操作,可能会改变原来的数据,所以必定会刷新缓存!
3.查询不同的Mapper.xml
4.手动清理缓存!
一级缓存默认是开启的,只在一次SqlSession中有效,也就是拿到连接到关闭连接这个区间段!
—级缓存就是一个Map。
1.开启全局缓存
<settings>
<setting name="logImpl" value="STDOUT_LOGGING"/>
<setting name="mapUnderscoreToCamelCase" value="true"/>
<setting name="cacheEnabled" value="true"/>
settings>
2.在要使用二级缓存的Mapper中开启
<cache readOnly="true"/>
也可以自定义参数
<cache
eviction="FIFO"
flushInterval="60000"
size="512"
readOnly="true"/>
3.测试
1.问题:我们需要将实体类序列化!否则就会报错!
只要开启了二级缓存,在同一个Mapper下就有效·所有的数据都会先放在一级缓存中;
只有当会话提交,或者关闭的时候,才会提交到二级缓冲中!
<cache/> 只在同一个namespace下有效 且必须<cache readOnly="true"/>这样使用,否则报错
Ehcache是一种广泛使用的开源java分布式缓存。主要面向通用缓存
<dependency>
<groupId>org.mybatis.cachesgroupId>
<artifactId>mybatis-ehcacheartifactId>
<version>1.2.1version>
dependency>
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
updateCheck="false">
<diskStore path="java.io.tmpdir/Tmp_EhCache"/>
<defaultCache
eternal="false"
maxElementsInMemory="10000"
overflowToDisk="false"
diskPersistent="false"
timeToIdleSeconds="1800"
timeToLiveSeconds="259200"
memoryStoreEvictionPolicy="LRU"/>
<cache
name="cloud_user"
eternal="false"
maxElementsInMemory="5000"
overflowToDisk="false"
diskPersistent="false"
timeToIdleSeconds="1800"
timeToLiveSeconds="1800"
memoryStoreEvictionPolicy="LRU"/>
ehcache>
oupId>org.mybatis.caches
mybatis-ehcache
1.2.1
#### 在mapper中指定使用我们的ehcache缓存实现!
```xml
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
updateCheck="false">
<diskStore path="java.io.tmpdir/Tmp_EhCache"/>
<defaultCache
eternal="false"
maxElementsInMemory="10000"
overflowToDisk="false"
diskPersistent="false"
timeToIdleSeconds="1800"
timeToLiveSeconds="259200"
memoryStoreEvictionPolicy="LRU"/>
<cache
name="cloud_user"
eternal="false"
maxElementsInMemory="5000"
overflowToDisk="false"
diskPersistent="false"
timeToIdleSeconds="1800"
timeToLiveSeconds="1800"
memoryStoreEvictionPolicy="LRU"/>
ehcache>