Spring

在原始的分层架构实现中，负责响应请求的Controller层依赖于业务逻辑处理的Service层，而业务逻辑处理的service层又依赖与数据访问Dao层。上下层间相互依赖耦合，耦合的缺陷在于牵一发而动全身，不利于后期维护拓展。

为了分层解耦，Spring采用IoC控制反转和DI依赖注入，来解决耦合问题。

IoC控制反转

IoC（Inversion of Control）控制反转的思想：使用对象时，不再主动new产生对象，而是转换为外部提供对象，此过程中对象创建控制权由程序转移到外部。

• Spring技术对IoC思想进行了实现，Spring提供了一个容器，称为IoC容器，用来充当IoC思想中的“外部”的概念
• IoC容器负责对象的创建、初始化等一系列工作，被创建或者被管理的对象在IoC容器中统称为Bean

DI 依赖注入

IoC控制反转，相当于将对象交由容器管理，是对象到容器的过程，而DI（Dependency依赖注入）则是从容器中取出对应的对象的过程。

Bean

Bean基础配置

name

bean标签指定name属性配置别名：

scope

bean标签的scope属性配置bean的作用范围，默认scope属性值为singleton，bean对象是单例的。如果要构建非单例对象，指定属性值为prototype

Bean实例化方式

bean本质就是一个对象，它的构造方式有以下4种：

• 1、通过无参的构造方法（默认构造方法）实例化bean，因此一个要交给IoC容器的类，如果无参构造方法不存在，想构造bean会抛出异常BeanCreationException
• 2、使用静态工厂实例化bean，先实例化静态工厂类，然后执行工厂方法属性字段为静态工厂的生产方法。
• 3、使用实例工厂实例化bean。先实例化实例工厂类，然后在实例化bean时指定factory-method属性和factory-bean属性。
• 4、使用FactoryBean的方式。这种方式本质上与方式3一样，只不过spring为我们提供了接口规范，来编写bean配置时更加简洁。

使用工厂方式实例化，便于对实例化过程进行拓展

FactoryBean是Spring提供的接口标准。

Bean的生命周期

对 Prototype Bean 来说，当用户 getBean 获得 Prototype Bean 的实例后，IOC 容器就不再对当前实例进行管理，而是把管理权交由用户，此后再 getBean 生成的是新的实例。

所以我们描述 Bean 的生命周期，都是指的 Singleton Bean。

Bean生命周期过程：

• 第1步，实例化一个Bean对象；construct
• 第2步，为Bean设置相关属性和依赖；propertiesSet
• 第3步，初始化；init
• 第4步，销毁；destroy

Bean的生命周期控制方法的设置有两种方式：
第一种：先在类中提供生命周期控制方法，然后在Bean配置时，在bean标签中指定init-method 和 destroy - method。

第二种方式：可以通过实现Spring提供的InitializingBean接口和DisposableBean接口：

生命周期的顺序：

从上边可以看到bean标签上的init方法和destroy方法比实现的接口的方法范围更大一些（先init，后destroy）。

注意：要想看到destroy的效果，需要我们手动关闭IOC容器。
关闭IOC容器的方式可以是通过容器的close()方法，也可以是通过容器的registerShutdownHook()方法。

依赖注入方式

提供set()方法或者使用构造器。

第1种情况：使用set依赖注入一个引用类型。

第2种情况：使用set注入简单类型

第3种情况，使用构造器注入简单类型：

第4种情况，使用构造器注入引用类型：

依赖自动装配

bean标签使用autowire属性自动装配，

autowire属性值可选择如下：

Mybatis-Plus

Mybatis-Plus是Mybatis的增强工具，在Mybatis基础上只做增强，不做改变，为简化开发，提供效率设计。

配置

添加依赖：

<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.1</version>
</dependency>

在Springboot的启动类中添加@MapperScan注解，扫描mapper包。

@SpringBootApplication
@MapperScan("com.atguigu.mybatisplus.mapper")
public class MybatisplusApplication {
public static void main(String[] args) {
		SpringApplication.run(MybatisplusApplication.class, args);
	}
}

在application.yml中配置日志输出：

# 配置MyBatis日志
mybatis-plus:
	configuration:
		log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

BaseMapper

BaseMapper是Mybatis-Plus提供的模板mapper，其中包含了基本的CRUD方法，泛型为操作的实体类型。

以User实体为例：

@Data //lombok注解
public class User {
	private Long id;
	private String name;
	private Integer age;
	private String email;
}

我们在编写自己的mapper时，可以继承这个模板mapper。

public interface UserMapper extends BaseMapper<User> {
}

增：

@Test
public void testInsert(){
User user = new User(null, "张三", 23, "zhangsan@atguigu.com");
//INSERT INTO user ( id, name, age, email ) VALUES ( ?, ?, ?, ? )
int result = userMapper.insert(user);
System.out.println("受影响行数："+result);
//1475754982694199298
System.out.println("id自动获取："+user.getId());
}

删：

@Test
public void testDeleteById(){
//通过id删除用户信息
//DELETE FROM user WHERE id=?
int result = userMapper.deleteById(1475754982694199298L);
System.out.println("受影响行数："+result);

@Test
public void testDeleteBatchIds(){
//通过多个id批量删除
//DELETE FROM user WHERE id IN ( ? , ? , ? )
List<Long> idList = Arrays.asList(1L, 2L, 3L);
int result = userMapper.deleteBatchIds(idList);
System.out.println("受影响行数："+result);
}
}

@Test
public void testDeleteByMap(){
//根据map集合中所设置的条件删除记录
//DELETE FROM user WHERE name = ? AND age = ?
Map<String, Object> map = new HashMap<>();
map.put("age", 23);
map.put("name", "张三");
int result = userMapper.deleteByMap(map);
System.out.println("受影响行数："+result);
}

改：

@Test
public void testUpdateById(){
User user = new User(4L, "admin", 22, null);
//UPDATE user SET name=?, age=? WHERE id=?
int result = userMapper.updateById(user);
System.out.println("受影响行数："+result);
}

查：

@Test
public void testSelectById(){
//根据id查询用户信息
//SELECT id,name,age,email FROM user WHERE id=?
User user = userMapper.selectById(4L);
System.out.println(user);
}

@Test
public void testSelectBatchIds(){
//根据多个id查询多个用户信息
//SELECT id,name,age,email FROM user WHERE id IN ( ? , ? )
List<Long> idList = Arrays.asList(4L, 5L);
List<User> list = userMapper.selectBatchIds(idList);
list.forEach(System.out::println);
}

@Test
public void testSelectByMap(){
//通过map条件查询用户信息
//SELECT id,name,age,email FROM user WHERE name = ? AND age = ?
Map<String, Object> map = new HashMap<>();
map.put("age", 22);
map.put("name", "admin");
List<User> list = userMapper.selectByMap(map);
list.forEach(System.out::println);
}

@Test
public void testSelectList(){
//查询所有用户信息
//SELECT id,name,age,email FROM user
List<User> list = userMapper.selectList(null);
list.forEach(System.out::println);
}

通用Service

说明:
通用 Service CRUD 封装IService接口，进一步封装 CRUD 采用 get 查询单行 remove 删除 list 查询集合 page 分页 前缀命名方式区分 Mapper 层避免混淆，
泛型 T 为任意实体对象
建议如果存在自定义通用 Service 方法的可能，请创建自己的 IBaseService 继承
Mybatis-Plus 提供的基类
官网地址：https://baomidou.com/pages/49cc81/#service-crud-%E6%8E%A5%E5%8F%
A3

使用步骤：
1、创建Service接口和实现类。

/**
* UserService继承IService模板提供的基础功能
*/
public interface UserService extends IService<User> {
}

/**
* ServiceImpl实现了IService，提供了IService中基础功能的实现
* 若ServiceImpl无法满足业务需求，则可以使用自定的UserService定义方法，并在实现类中实现
*/
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements
UserService {
}

使用案例：
1、测试查询记录数：

@Autowired
private UserService userService;
@Test
public void testGetCount(){
long count = userService.count();
System.out.println("总记录数：" + count);
}

2、测试批量插入：

@Test
public void testSaveBatch(){
// SQL长度有限制，海量数据插入单条SQL无法实行，
// 因此MP将批量插入放在了通用Service中实现，而不是通用Mapper
ArrayList<User> users = new ArrayList<>();
for (int i = 0; i < 5; i++) {
User user = new User();
user.setName("ybc" + i);
user.setAge(20 + i);
users.add(user);
}
//SQL:INSERT INTO t_user ( username, age ) VALUES ( ?, ? )
userService.saveBatch(users);
}

常用注解

@TableName

在使用MyBatis-Plus实现基本的CRUD时，我们并没有指定要操作的表，只是在
Mapper接口继承BaseMapper时，设置了泛型User，而操作的表为user表
由此得出结论，MyBatis-Plus在确定操作的表时，由BaseMapper的泛型决定，即实体类型决
定，且默认操作的表名和实体类型的类名一致

若实体类类型的类名和要操作的表的表名不一致，会出现什么问题？

将表user更名为t_user，测试查询功能，就会出错。

此时我们可以使用@TableName注解指定要操作的表名：

还可以使用全局配置:
在开发的过程中，我们经常遇到以上的问题，即实体类所对应的表都有固定的前缀，例如t_或tbl_
此时，可以使用MyBatis-Plus提供的全局配置，为实体类所对应的表名设置默认的前缀，那么就
不需要在每个实体类上通过@TableName标识实体类对应的表

那么可以在application.yml中使用mybatis-plus的配置：

mybatis-plus:
	configuration:
		# 配置MyBatis日志
		log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
	global-config:
		db-config:
			# 配置MyBatis-Plus操作表的默认前缀
			table-prefix: t_

@TableId

MyBatis-Plus在实现CRUD时，会默认将id作为主键列，并在插入数据时，默认基于雪花算法的策略生成id。

若实体类和表中表示的主键不是id，而是其他字段，如uid，则需要在实体类的主键表示的属性上使用@TableId注解标识主键：

@TableId的value属性
若实体类中主键对应的属性为id，而表中表示主键的字段为uid，此时若只在属性id上添加注解
@TableId，则抛出异常Unknown column ‘id’ in ‘field list’，即MyBatis-Plus仍然会将id作为表的
主键操作，而表中表示主键的是字段uid
此时需要通过@TableId注解的value属性，指定表中的主键字段，@TableId(“uid”)或
@TableId(value=“uid”)

@TableId的type属性
type属性用来定义主键策略

配置全局主键策略：

mybatis-plus:
	configuration:
		# 配置MyBatis日志
		log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
global-config:
	db-config:
		# 配置MyBatis-Plus操作表的默认前缀
		table-prefix: t_
		# 配置MyBatis-Plus的主键策略
		id-type: auto

雪花算法

需要选择合适的方法去应对数据规模的增长，以应对逐渐增长的访问压力和数据量。数据库的扩展方式主要包括：业务分库、主从复制、数据库分表。

• 垂直分表
  垂直分表适合将表中某些不常用且占了大量空间的列拆分出去。
  例如，前面示意图中的 nickname 和 description 字段，假设我们是一个婚恋网站，用户在筛选其他用
  户的时候，主要是用 age 和 sex 两个字段进行查询，而 nickname 和 description 两个字段主要用于展
  示，一般不会在业务查询中用到。description 本身又比较长，因此我们可以将这两个字段独立到另外
  一张表中，这样在查询 age 和 sex 时，就能带来一定的性能提升。
• 水平分表
  水平分表适合表行数特别大的表，有的公司要求单表行数超过 5000 万就必须进行分表，这个数字可以
  作为参考，但并不是绝对标准，关键还是要看表的访问性能。对于一些比较复杂的表，可能超过 1000
  万就要分表了；而对于一些简单的表，即使存储数据超过 1 亿行，也可以不分表。
  水平分表相比垂直分表，会引入更多的复杂性，例如要求全局唯一的数据id该如何处理
  • 主键自增
    以最常见的用户id为例，可以按照1000000 的范围大小进行分段，1 ~ 999999 放到表 1中，1000000 ~ 1999999 放到表2中，以此类推。这样的缺点在于，可能出现分布不均匀的情况，有可能某个分段实际存储的数据量只有 1 条，而
    另外一个分段实际存储的数据量有 1000 万条。
  • 取模
    同样以用户 ID 为例，假如我们一开始就规划了 10 个数据库表，可以简单地用 user_id % 10 的值来表示数据所属的数据库表编号，ID 为 985 的用户放到编号为 5 的子表中，ID 为 10086 的用户放到编号为 6 的子表中。这种方式的优点在于表分布比较均匀，但是缺点在于扩充新的表很麻烦，所有的数据都需要重新分布。
  • 雪花算法
    雪花算法是由Twitter公布的分布式主键生成算法，它能够保证不同表的主键的不重复性，以及相同表的有序性。

雪花算法的原理：


雪花算法的优点：整体上按照时间自增排序，并且整个分布式系统内不会产生ID碰撞，效率较高。

@TableField

MyBatis-Plus在执行SQL语句时，要保证实体类中的属性名和
表中的字段名一致
如果实体类中的属性名和字段名不一致的情况，会出现什么问题呢？

情况1：
若实体类中属性使用驼峰命名风格，而表中字段属性使用的是下划线命名风格，例如如实体类属性userName，表中字段user_name此时MyBatis-Plus会自动将下划线命名风格转化为驼峰命名风格相当于在MyBatis中配置。

情况2：
若实体类中的属性和表中字段不满足情况1，例如实体类属性为name，而表中字段为username，此时需要在实体类属性上使用@TableFile(“username”)设置属性所对应的字段名。

@TableLogic

• 物理删除：真实删除，将对应数据从数据库中删除，之后查询不到此条被删除的数据
• 逻辑删除：假删除，将对应数据中代表是否被删除字段的状态修改为“被删除状态”，之后在数据库
  中仍旧能看到此条数据记录
• 使用场景：可以进行数据恢复

实现逻辑删除的步骤：
步骤1：数据库中创建逻辑删除状态字段，设置默认值为0

步骤2：实体类中添加逻辑删除属性，并添加注解@TableLogic

步骤3：测试
测试删除功能，真正执行的是修改
UPDATE t_user SET is_deleted=1 WHERE id=? AND is_deleted=0
测试查询功能，被逻辑删除的数据默认不会被查询
SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE is_deleted=0

条件构造器和常用接口

Wrapper：条件构造抽象类，最顶端父类。帮助我们构造增删改查的条件。

QueryWrapper

例1：组装查询条件：

@Test
public void test01(){
//查询用户名包含a，年龄在20到30之间，并且邮箱不为null的用户信息
//SELECT id,username AS name,age,email,is_deleted FROM t_user WHERE
	is_deleted=0 AND (username LIKE ? AND age BETWEEN ? AND ? AND email IS NOT NULL)
	QueryWrapper<User> queryWrapper = new QueryWrapper<>();
	queryWrapper.like("username", "a")
	.between("age", 20, 30)
	.isNotNull("email");
	List<User> list = userMapper.selectList(queryWrapper);
	list.forEach(System.out::println);
}

例2：组装排序条件

UpdateWrapper

插件

MyBatis Plus自带分页插件，只要简单的配置即可实现分页功能。

使用步骤：
1、添加配置类

@Configuration
@MapperScan("com.atguigu.mybatisplus.mapper") //可以将主类中的注解移到此处
public class MybatisPlusConfig {
@Bean
public MybatisPlusInterceptor mybatisPlusInterceptor() {
		MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
		interceptor.addInnerInterceptor(new
		PaginationInnerInterceptor(DbType.MYSQL));
		return interceptor;
	}
}

2、测试

@Test
public void testPage(){
//设置分页参数
Page<User> page = new Page<>(1, 5);
userMapper.selectPage(page, null);
//获取分页数据
List<User> list = page.getRecords();
list.forEach(System.out::println);
System.out.println("当前页："+page.getCurrent());
System.out.println("每页显示的条数："+page.getSize());
System.out.println("总记录数："+page.getTotal());
System.out.println("总页数："+page.getPages());
System.out.println("是否有上一页："+page.hasPrevious());
System.out.println("是否有下一页："+page.hasNext());
}