ZJC'S BLOG 2022-03-10T09:45:30.170Z http://yoursite.com/ ZJC Hexo Mybatis-Plus学习笔记 http://yoursite.com/2022/03/10/Mybatis-Plus%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/ 2022-03-10T09:43:45.396Z 2022-03-10T09:45:30.170Z Mybatis-Plus

https://www.kuangstudy.com/bbs/1366329082232467457

https://blog.csdn.net/qq_43649223/article/details/108885374?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163599762616780269885191%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=163599762616780269885191&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-2-108885374.pc_search_all_es&utm_term=Mybatis-Plus%E7%8B%82%E7%A5%9E&spm=1018.2226.3001.4187

笔记

在这里插入图片描述

特性

  • 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
  • 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作，BaseMapper
  • 强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求，以后简单的CRUD操作，不用自己编写了 ！
  • 支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
  • 支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
  • 支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
  • 支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
  • 内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用（自动帮你生成代码）
  • 内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
  • 分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
  • 内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
  • 内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

1.快速入门

官方链接：https://baomidou.com/guide/\

使用第三方插件:

  1. 导入对应的依赖
  2. 研究依赖如何配置
  3. 代码如何编写
  4. 提高扩展技术能力

步骤

1.创建数据库 mybatis_plus

2.创建表

1
2
3
4
5
6
7
8
9
10
11
DROP TABLE IF EXISTS user;

CREATE TABLE user
(
id BIGINT(20) NOT NULL COMMENT '主键ID',
name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
age INT(11) NULL DEFAULT NULL COMMENT '年龄',
email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY (id)
);
--真实开发环境中,version(乐观锁),deleted(逻辑删除),gmt_create,gmt_modified

插入数据

1
2
3
4
5
6
7
8
DELETE FROM user;

INSERT INTO user (id, name, age, email) VALUES
(1, 'Jone', 18, 'test1@baomidou.com'),
(2, 'Jack', 20, 'test2@baomidou.com'),
(3, 'Tom', 28, 'test3@baomidou.com'),
(4, 'Sandy', 21, 'test4@baomidou.com'),
(5, 'Billie', 24, 'test5@baomidou.com');

3.编写项目,初始化项目! 使用SpringBoot初始化!

4.导入依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!--mysql-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<!--lombok-->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>
<!--mybatis-plus-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus-boot-starter</artifactId>
    <version>3.0.5</version>
</dependency>

说明:我们使用mybatis-plus 可以节省我们大量的代码,尽量不要同时导入mybatis和mybatis-plus因为版本有差异!

5.连接数据库!这一步和mybatis相同!

1
2
3
4
5
6
7
# mysql 5 驱动不同  com.mysql.jdbc.Driver

# mysql 8 驱动不同 com.mysql.cj.jdbc.Driver . 需要增加时区的配置 serverTimezone=GMT%2B8
spring.datasource.username=codeyuaiiao
spring.datasource.password=3615yuhaijiao
spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?useSSL=false&useUnicode=true&characterEncoding=utf-8
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

(传统的方式pojo-dao(连接mybatis,配置mapper.xml文件)-service-controller)

6.使用了mybatis-plus之后

  • pojo
1
2
3
4
5
6
7
8
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Long id;
    private String name;
    private Integer age;
    private String email;
  • mapper接口
1
2
3
4
5
6
7
8
9
10
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.codeyuaiiao.pojo.User;
import org.springframework.stereotype.Repository;

//在对应的mapper上面继承基本的类 BaseMapper
@Repository//代表持久层
public interface UserMapper extends BaseMapper<User> {
    //所有CRUD操作都已经编写完成了
    //你不需要向以前一样配置一大堆文件了!
}

注意点:需要在主启动类MybatisPlusApplication上扫描我们Mapper包下的所有接口

@MapperScan("com.zjc.mapper")

  • 测试类中测试
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@SpringBootTest
class MybatisPlusApplicationTests {

    //继承了BaseMapper, 所有的方法都来自己父类
    //我们也可以编写自己的扩展方法
    @Autowired
    private UserMapper userMapper;

    @Test
    void contextLoads() {
        //参数是一个Wrapper , 条件构造器,这里我们先不用 --null
        //查询全部用户
        List<User> users = userMapper.selectList(null);
        users.forEach(System.out::println);
    }
}
  • 查询结果:

在这里插入图片描述

1
2
3
4
思考问题

1. sql谁帮我们写的?—mybatis-plus
2. 方法谁帮我们写的?—mybatis-plus

2.配置日志

我们所有的sql是不可见的,我们希望知道他是怎么执行的,所以我们必须看日志!

1
2
# 配置日志  (默认控制台输出)
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

在这里插入图片描述

配置完日志之后你会喜欢上mybatis-plus!

3.CRUD扩展

1.插入数据

1
2
3
4
5
6
7
8
9
10
11
@Test
public void testInsert(){
    User user = new User();
    user.setName("codeyuaiiao");
    user.setAge(3);
    user.setEmail("747557612@qq.com");
    int result = userMapper.insert(user);
    System.out.println(result);
    System.out.println(user);

}

在这里插入图片描述

注意点:数据库插入的id默认值为:全局的唯一id

2.主键生成策略

默认 ID_WORKER 全局唯一id

对应数据库中的主键(uuid.自增id.雪花算法.redis.zookeeper)

分布式系统唯一id生成:https://www.cnblogs.com/haoxinyue/p/5208136.html

雪花算法😦Twitter的snowflake算法)

snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0.可以保证几乎全球唯一

主键自增

我们需要配置主键自增:

  1. 实体类字段上@TableId(type = IdType.AUTO)
  2. 数据库字段一定要是自增!

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

其余源码解释

1
2
3
4
5
6
7
8
9
10
11
public enum IdType {
     
    AUTO(0),//数据库ID自增  
    NONE(1),//该类型为未设置主键类型      
    INPUT(2),//用户输入ID
       //该类型可以通过自己注册自动填充插件进行填充  
    
//以下3种类型、只有当插入对象ID 为空，才自动填充。     
    ID_WORKER(3),//全局唯一ID (idWorker)      
    UUID(4),//全局唯一ID (UUID)          
    ID_WORKER_STR(5);//字符串全局唯一ID (idWorker 的字符串表示)

3.更新数据

动态sql

注意:updateById()参数是 一个对象!

1
2
3
4
5
6
7
8
9
10
11
//测试更新
@Test
public void testUpdate(){
    User user = new User();
    user.setId(2L);
    user.setName("哈哈哈哈哈哈哈");
    //        注意:updateById()参数是 一个对象!
    int i = userMapper.updateById(user);
    System.out.println(i);

}

在这里插入图片描述

在这里插入图片描述

所有的sql都是动态帮你配置的.

4.自动填充

创建时间 . 修改时间! 这些个操作都是自动化完成的,我们不希望手动更新!

阿里巴巴开发手册:所有的数据库表:gmt_create .gmt_modified几乎所有的表都要配置上!而且需要自动化!

方式一:数据库级别（工作中不允许修改数据库级别）

1.在表中新增字段 create_time , update_time

img

2.再次测试插入方法,我们需要先把实体类同步

1
2
private Data creatTime;
private Data updateTime;

再次更新查看结果即可

img

方式二:代码级别

1.删除数据库默认值

img

2.实体类字段属性上添加注解

1
2
3
4
5
6
7
//记住用util包下的Date!!
//字段添加填充内容
@TableField(fill = FieldFill.INSERT)
private Date createTime;

@TableField(fill = FieldFill.INSERT_UPDATE)
private Date updateTime;

3.编写处理器来处理这个注解

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Slf4j//日志
@Component//丢到springboot里   一定不要忘记把处理器加到Ioc容器中!
public class MyMetaObjectHandler extends MetaObjectHandler {//extends??
    @Override//插入时的填充策略
    public void insertFill(MetaObject metaObject) {
        log.info("==start insert ······==");
        //setFieldValByName(java.lang.String fieldName, java.lang.Object fieldVal, org.apache.ibatis.reflection.MetaObject metaObject)
        this.setFieldValByName("createTime",new Date(),metaObject);
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
    @Override//更新时的填充策略
    public void updateFill(MetaObject metaObject) {
        log.info("==start update ······==");
        this.setFieldValByName("updateTime",new Date(),metaObject);
    }
}

4、测试插入/更新，观察时间

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
@Test//测试插入
public void insertTest(){
    User user = new User();
    user.setName("live");
    user.setAge(22);
    user.setEmail("1314@qq.com");
    Integer result = userMapper.insert(user); //会帮我们自动生成id
    System.out.println(result); //受影响的行数
    System.out.println(user); //通过日志发现id会自动回填
}
@Test//测试更新
public void updateTest(){
    User user = new User();
    user.setId(1359495921613004803L);
    user.setName("test3");
    user.setAge(18); //通过条件自动拼接动态Sql
    user.setEmail("test3@qq.com");
    int i = userMapper.updateById(user);//updateById，但是参数是个user
    System.out.println(i);
}

5测试更新,观察时间即可!

img

5.乐观锁&悲观锁

乐观锁: 顾名思义十分乐观,他总是认为不会出现问题,无论干什么都不去上锁!如果出现了问题,再次更新值测试

悲观锁;顾名思义十分悲观,他总是认为出现问题,无论干什么都会上锁!再去操作!

我们这里主要讲解 乐观锁机制!

乐观锁实现方式:

  • 取出记录时,获取当前version
  • 更新时,带上这个version
  • 执行更新时,set version = newVersion where version = oldVersion
  • 如果version不对,就更新失败
1
2
3
4
5
6
7
乐观锁：先查询，获得版本号 
-- A
update user set name = "wsk",version = version+1 
where id = 1 and version = 1
-- B  （B线程抢先完成，此时version=2，会导致A线程修改失败！）
update user set name = "wsk",version = version+1 
where id = 1 and version = 1

测试一下Mybatis-Plus乐观锁插件

1、给数据库中增加version字段

img

2、实体类加对应的字段

1
2
@Version//乐观锁version注解
private Integer version;

3、注册组件

1
2
3
4
5
6
7
8
9
10
11
//扫描mapper文件夹
@MapperScan("com.wsk.mapper")//交给mybatis做的，可以让这个配置类做扫描
@EnableTransactionManagement//自动管理事务
@Configuration//配置类
public class MyBatisPlusConfig {
    //注册乐观锁插件
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor(){
        return new OptimisticLockerInterceptor();
    }
}

4、测试一下

  • 成功
1
2
3
4
5
6
7
8
9
10
@Test//测试乐观锁成功
public void testOptimisticLocker1(){
    //1、查询用户信息
    User user = userMapper.selectById(1L);
    //2、修改用户信息
    user.setAge(18);
    user.setEmail("2803708553@qq.com");
    //3、执行更新操作
    userMapper.updateById(user);
}

img

img

  • 失败
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@Test//测试乐观锁失败  多线程下
public void testOptimisticLocker2(){
    //线程1
    User user1 = userMapper.selectById(1L);
    user1.setAge(1);
    user1.setEmail("2803708553@qq.com");
    //模拟另外一个线程执行了插队操作
    User user2 = userMapper.selectById(1L);
    user2.setAge(2);
    user2.setEmail("2803708553@qq.com");
    userMapper.updateById(user2);
    //自旋锁来多次尝试提交！
    userMapper.updateById(user1);//如果没有乐观锁就会覆盖插队线程的值
}

img

img

6.查询操作

  • 通过id查询单个用户
1
2
3
4
5
@Test//通过id查询单个用户
public void testSelectById(){
    User user = userMapper.selectById(1L);
    System.out.println(user);
}

img

  • 通过id查询多个用户
1
2
3
4
5
6
@Test//通过id查询多个用户
public void testSelectBatchIds(){
    List<User> users = userMapper.selectBatchIds(Arrays.asList(1L, 2L, 3L));
    users.forEach(System.out::println);
    //System.out.println(users);
}

img

img

  • 条件查询 通过map封装
1
2
3
4
5
6
7
8
9
@Test//通过条件查询之一  map
public void testMap(){
    HashMap<String, Object> map = new HashMap<>();
    //自定义要查询的
    map.put("name","www");
    map.put("age",18);
    List<User> users = userMapper.selectByMap(map);
    users.forEach(System.out::println);
}

img

img

  • 分页查询

分页在网站的使用十分之多！

1、原始的limit分页

2、pageHelper第三方插件

3、MybatisPlus其实也内置了分页插件！

使用：

1、配置拦截器组件

1
2
3
4
5
 //分页插件
@Bean
public PaginationInterceptor paginationInterceptor() {
    return new PaginationInterceptor();
}

2、直接使用page对象即可

1
2
3
4
5
6
7
8
9
@Test//测试分页查询
public void testPage(){
    //参数一current：当前页   参数二size：页面大小
    //使用了分页插件之后，所有的分页操作都变得简单了
    Page<User> page = new Page<>(2,5);
    userMapper.selectPage(page,null);
    page.getRecords().forEach(System.out::println);
    System.out.println("总页数==>"+page.getTotal());
}

img

7.基本的删除&&逻辑删除

基本的删除任务：

img

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@Test
public void testDeleteById(){
    userMapper.deleteById(1359507762519068681L);
}
@Test
public void testDeleteBatchIds(){
  userMapper.deleteBatchIds(Arrays.asList(1359507762519068675L,1359507762519068676L));
}
@Test
public void testD(){
    HashMap<String, Object> map = new HashMap<>();
    map.put("age","18");
    map.put("name","lol");
    userMapper.deleteByMap(map);
}

物理删除:从数据库中直接移除

逻辑删除: 在数据库中没有被移除,而是通过一个变量来让他失效! deleted=0=>deleted=1

管理员可以查看被删除的记录!防止数据的丢失,类似于回收站!

测试:

1.在数据表中增加一个deleted字段

在这里插入图片描述

2.实体类中增加属性

1
2
3
//逻辑删除
@TableLogic
private Integer deleted;

3.配置

1
2
3
4
5
//注册逻辑删除
@Bean
public ISqlInjector sqlInjector(){
    return new LogicSqlInjector();
}

配置

1
2
3
# 配置逻辑删除 没删除的为0 删除的为1
mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

走的是更新操作,不是删除操作

img

发现： 记录还在，deleted变为1

再次测试查询被删除的用户，发现查询为空

img

以上的所有CRUD操作及其扩展,我们都必须精通掌握!会大大提好你的工作和写项目的效率

4.性能分析插件

我们在平时的开发中,会遇到一些慢sql.

MP也提供了性能分析插件,如果超过这个时间就停止运行!

性能分析拦截器作用：用于输出每条sql语句及其执行时间

1.导入插件

1
2
3
4
5
6
7
8
9
 //性能分析插件
@Bean
@Profile({"dev","test"})//设置dev开发、test测试 环境开启  保证我们的效率
public PerformanceInterceptor performanceInterceptor(){
    PerformanceInterceptor performanceInterceptor = new PerformanceInterceptor();
    performanceInterceptor.setMaxTime(100);//设置sql最大执行时间*ms，如果超过了则不执行
    performanceInterceptor.setFormat(true);//开启sql格式化
    return performanceInterceptor;
}

记住在SpringBoot中配置环境为 dev或者test环境

application.properties中添加设置开发环境

1
2
#设置开发环境
spring.profiles.active=dev

2.测试查询

1
2
3
4
5
6
7
8

@Test
void contextLoads() {
    //参数是一个wrapper ，条件构造器，这里我们先不用 null
    //查询全部的用户
    List<User> userList = userMapper.selectList(null);
    userList.forEach(System.out::println);
}

在这里插入图片描述

5.条件构造器Wrapper

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
package com.kuang;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.kuang.mapper.UserMapper;
import com.kuang.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;
import java.util.Map;

@SpringBootTest
public class WrapperTest {

    @Autowired
    private UserMapper userMapper;

    @Test
    void contextLoads() {
        // 查询name不为空的用户，并且邮箱不为空的用户，年龄大于等于12
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper
                .isNotNull("name")
                .isNotNull("email")
                .ge("age",12);
        userMapper.selectList(wrapper).forEach(System.out::println); // 和我们刚才学习的map对比一下
    }

    @Test
    void test2(){
        // 查询名字狂神说
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.eq("name","狂神说");
       //查询一个数据selectOne，若查询出多个会报错
      //Expected one result (or null) to be returned by selectOne(), but found: *
      //若出现多个结果使用list或map
        User user = userMapper.selectOne(wrapper); // 查询一个数据，出现多个结果使用List 或者 Map
        System.out.println(user);
    }

    @Test
    void test3(){
        // 查询年龄在 20 ~ 30 岁之间的用户
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.between("age",20,30); // 区间
        Integer count = userMapper.selectCount(wrapper);// 查询结果数
        System.out.println(count);
    }

    // 模糊查询
    @Test
    void test4(){
        // 查询年龄在 20 ~ 30 岁之间的用户
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        // 左和右  t%
        wrapper
                .notLike("name","e")
                .likeRight("email","t");

        List<Map<String, Object>> maps = userMapper.selectMaps(wrapper);
        maps.forEach(System.out::println);
    }

    // 模糊查询
    @Test
    void test5(){
  //模糊查询 
    // SELECT id,name,age,email,version,deleted,create_time,update_time 
    //FROM user 
    //WHERE deleted=0 AND id IN 
    //(select id from user where id<5)
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        // id 在子查询中查出来
        wrapper.inSql("id","select id from user where id<3");

        List<Object> objects = userMapper.selectObjs(wrapper);
        objects.forEach(System.out::println);
    }

    //测试六
    @Test
    void test6(){
        
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        // 通过id进行排序
        wrapper.orderByAsc("id");

        List<User> users = userMapper.selectList(wrapper);
        users.forEach(System.out::println);
    }

}

Mysql => JDBC => Mybatis => MybatisPlus\

6.代码自动生成

dao、pojo、service、controller都给我自己去编写完成！

AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。只需要改实体类名字 和包名 还有 数据库配置即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
package com.z;
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.po.TableFill;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import java.util.ArrayList;
//代码自动生成器
public class WskCode {
    public static void main(String[] args) {
        //我们需要构建一个代码生成器对象
        AutoGenerator mpg = new AutoGenerator();
        //怎么样去执行，配置策略
        //1、全局配置
        GlobalConfig gc = new GlobalConfig();
        String projectPath = System.getProperty("user.dir");//获取当前目录
        gc.setOutputDir(projectPath+"/src/main/java");//输出到哪个目录
        gc.setAuthor("zjc");
        gc.setOpen(false);
        gc.setFileOverride(false);//是否覆盖
        gc.setServiceName("%sService");//去Service的I前缀
        gc.setIdType(IdType.ID_WORKER);
        gc.setDateType(DateType.ONLY_DATE);
        gc.setSwagger2(true);
        mpg.setGlobalConfig(gc);
        //2、设置数据源
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUsername("root");
        dsc.setPassword("123456");
        dsc.setUrl("jdbc:mysql://localhost:3306/mybatis_plus?useSSL=false&serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setDbType(DbType.MYSQL);
        mpg.setDataSource(dsc);
        //3、包的配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName("study");
        pc.setParent("com.zjc");
        pc.setEntity("pojo");
        pc.setMapper("mapper");
        pc.setService("service");
        pc.setController("controller");
        mpg.setPackageInfo(pc);
        //4、策略配置
        StrategyConfig strategy = new StrategyConfig();
        strategy.setInclude("admin","danyuan","building","room");//设置要映射的表名,只需改这里即可
        strategy.setNaming(NamingStrategy.underline_to_camel);
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        strategy.setEntityLombokModel(true);//是否使用lombok开启注解
        strategy.setLogicDeleteFieldName("deleted");
        //自动填充配置
        TableFill gmtCreate = new TableFill("gmt_create", FieldFill.INSERT);
        TableFill gmtUpdate = new TableFill("gmt_update", FieldFill.INSERT_UPDATE);
        ArrayList<TableFill> tableFills = new ArrayList<>();
        tableFills.add(gmtCreate);
        tableFills.add(gmtUpdate);
        strategy.setTableFillList(tableFills);
        //乐观锁配置
        strategy.setVersionFieldName("version");
        strategy.setRestControllerStyle(true);//开启驼峰命名
        strategy.setControllerMappingHyphenStyle(true);//localhost:8080/hello_id_2
        mpg.setStrategy(strategy);
        mpg.execute();//执行
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<!--模板引擎 依赖:mybatis-plus代码生成的时候报异常-->
<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.0</version>
</dependency>
<!--配置ApiModel在实体类中不生效-->
<dependency>
    <groupId>com.spring4all</groupId>
    <artifactId>spring-boot-starter-swagger</artifactId>
    <version>1.5.1.RELEASE</version>
</dependency>
<!--freemarker-->
<dependency>
    <groupId>org.freemarker</groupId>
    <artifactId>freemarker</artifactId>
    <version>2.3.30</version>
</dependency>
<!--beetl-->
<dependency>
    <groupId>com.ibeetl</groupId>
    <artifactId>beetl</artifactId>
    <version>3.3.2.RELEASE</version>
</dependency>
]]> <h1 id="Mybatis-Plus"><a href="#Mybatis-Plus" class="headerlink" title="Mybatis-Plus"></a>Mybatis-Plus</h1> Spring5学习笔记 http://yoursite.com/2021/10/16/Spring5%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/ 2021-10-16T11:58:35.294Z 2021-10-17T17:33:23.166Z 1.Spring

1.1 简介

  • Spring ->春天，为开源软件带来春天

  • 2002，首次退出了Spring框架的雏形：interface21框架

  • Spring框架以interface21框架为基础，经过重新设计，并不断丰富其内涵，于2004年3月24日发布了1.0正式版

  • Spring的历年：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有技术框架！

  • SSH：Strut2 + Spring + Hibernate（全自动持久化框架）！

  • SSM：SpringMVC + Spring + MyBatis（半自动持久化框架，可自定义性质更强）

spring官网： https://spring.io/projects/spring-framework#overview
官方下载：https://repo.spring.io/release/org/springframework/spring/
GitHub： https://github.com/spring-projects/spring-framework
Spring Web MVC： https://mvnrepository.com/artifact/org.springframework/spring-webmvc/5.2.7.RELEASE

Spring Web MVC 和 Spring-JDBC的pom配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.7.RELEASE</version>
</dependency>

<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.7.RELEASE</version>
</dependency>

1.2 优点

  • Spring是一个开源的免费框架（容器）！
  • Spring是一个轻量级的、非入侵式的框架！
  • 控制反转（IOC），面向切面编程（AOP）
  • 支持事务处理，对框架整合的支持！（几乎市面上所有热门的框架都能整合进去）！

Spring就是一个轻量级的控制反转（IoC）和面向切面编程（AOP）的框架

1.3 组成

image-20210406162016538

  • 核心容器（SpringCore）
    核心容器提供Spring框架的基本功能。spring以bean的方式组织和管理Java应用的各个组件及其关系，spring使用BeanFactory来产生和管理Bean，是工厂模式的实现，BeanFactory使用控制反转（IoC）模式将应用的配置和依赖性规范与实际的应用程序代码分开

  • 应用上下文（Spring Context）

    Spring上下文是一个配置文件，向spring提供上下文信息，spring上下文包括企业服务

  • Spring面向切面编程（Spring AOP）
    AOP（Aspect Oriented Programming）通过配置管理特性，SpringAOP模块直接将面向方法的编程功能集成在了Spring框架中，Spring管理的任何对象都支持AOP，SpringAOP模块基于Spring的应用程序中的对象提供了事务管理服务，通过使用SpringAOP，不用依赖EJB组件，就可以将声明性事务管理集成在应用程序中

  • JDBC和DAO模块（Spring DAO）
    Dao（Data Access Object）
    JDBC、DAO的抽象层，提供了有意义的异常层次结构实现，可用该结构来管理异常处理，和不同数据库提供商抛出的错误信息，异常层次结构简化了错误处理，并且极大的降低了需要编写的代码数量，比如打开和关闭链接。

  • 对象实体映射（Spring ORM）
    ORM（Object Relational Mapping）
    Spring插入了若干个ORM框架，提供了ORM对象的关系工具，其中包括Hibernate，JDO和IBatisSQL Map等，所有这些都遵从Spring的通用事务和DAO异常层次结构

  • Web模块（Spring Web）
    web上下文模块建立应用程序上下文模块之上，基于web的应用程序提供了上下文，所以spring框架支持与Struts集成，web模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作

  • MVC模块（SpringWebMVC）
    MVC（Model View Controller）
    MVC框架是一个全功能的构建Web应用程序的MVC实现，通过策略接口，MVC框架编程高度可配置的，MVC容纳了大量视图技术，其中包括JSP，POI等，模型由JavaBean来构成，存放于m当中，而视图是一个接口，负责实现模型，控制器表示逻辑代码，由c的事情。spring框架的功能可以用在任何J2EE服务器当中，大多数功能也适用于不受管理的环境，spring的核心要点就是支持不绑定到特定J2EE服务的可重用业务和数据的访问对象，毫无疑问这样的对象可以在不同的J2EE环境，独立应用程序和测试环境之间重用

    1.4 扩展

​ 现代化的java开发 -> 基于Spring的开发！

在这里插入图片描述

Spring Boot

一个快速开发的脚手架
基于SpringBoot可以快速开发单个微服务
约定大于配置！

Spring Cloud

SpringCloud是基于SpringBoot实现的！
因为现在大多数公司都在使用SpringBoot进行快速开发，学习SpringBoot的前提，需要完全掌握Spring及SpringMVC！承上启下的作用！

2 .IoC(控制反转)理论指导

2.1 传统的调用

1.UserDao

1
2
3
4
package dao;
public interface UserDao {
void getUser();
}

2.UserDaoImpl

1
2
3
4
5
6
package dao;
public class UserDaoImpl implements UserDao{
public void getUser() {
System.out.println("默认获取用户数据");
}
}

3.UserService

1
2
3
4
package Service;
public interface UserService {
void getUser();
}

4.UserServiceImpl

1
2
3
4
5
6
7
8
9
10
package Service;
import dao.UserDao;
import dao.UserDaoImpl;

public class UserServiceImpl implements UserService{
UserDao userDao = new UserDaoImpl();
public void getUser(){
userDao.getUser();
}
}

测试：

1
2
3
4
5
6
7
8
9
10
11
package holle0;
import Service.UserService;
import Service.UserServiceImpl;

public class MyTest0 {
public static void main(String[] args) {
// 用户实际调用的是业务层，dao层他们不需要接触
UserService userService = new UserServiceImpl();
userService.getUser();
}
}

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改原代码！如果程序代码量十分大，修改一次的成本代价十分昂贵！

需要手动去new UserServiceImpl()

在这里插入图片描述

2.2 改进

我们使用一个Set接口实现。已经发生了革命性的变化！

1
2
3
4
5
6
7
8
//在Service层的实现类(UserServiceImpl)增加一个Set()方法
//利用set动态实现值的注入！
//DAO层并不写死固定调用哪一个UserDao的实现类
//而是通过Service层调用方法设置实现类！
private UserDao userDao;
public void setUserDao(UserDao userDao){
    this.userDao = userDao;
}

set() 方法实际上是动态改变了 UserDao userDao 的 初始化部分（new UserDaoImpl()）
((UserServiceImpl)userService).setUserDao(new UserDaoImpl());

  • 之前，程序是主动创建对象！控制权在程序猿手上！

  • 使用了set注入后，程序不再具有主动性，而是变成了被动的接受对象！（主动权在客户手上）

本质上解决了问题，程序员不用再去管理对象的创建,系统的耦合性大大降低，可以更专注在业务的实现上

​ 这是IoC（控制反转）的原型，反转(理解)：主动权交给了用户

在这里插入图片描述

注：这里的用户实际上是使用代码的人，不是不写代码的客户

使用IOC:

image-20210407101810695

image-20210407101915007

2.3 IOC本质

控制反转 IOC（Inversion of Control）是一种程序设计思想，DI（依赖注入）是实现IOC的一种方法，也有人认为DI只是IOC的另一种说法。没有IOC的程序中，我们使用面向对象编程，对象的创建于对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

在这里插入图片描述

在这里插入图片描述

3. HelloSpring

pom中引入依赖

1
2
3
4
5
6
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.7.RELEASE</version>
</dependency>

Hello:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package com.zjc.pojo;



public class Hello {

  private String str;

  public String getStr() {
    return str;
  }

  public void setStr(String str) {
    this.str = str;
  }

  @Override
  public String toString() {
    return "Hello{" +
      "str='" + str + '\'' +
      '}';
  }
}

beans.xml:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">


    <!--在Spring中创建对象，在Spring这些都称为bean
    类型 变量名 = new 类型();
    Holle holle = new Holle();
    
    bean = 对象(holle)
    id = 变量名(holle)
    class = new的对象(new Holle();)
    property 相当于给对象中的属性设值,让str="Spring"
    -->
    //xml依赖注入arg是通过构造函数property是通过seter方法，Name属性要和seter方法后面的名字相同
    <bean id="hello" class="com.kaung.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>
</beans>

测试类MyTest:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import pojo.Hello;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {

public static void main(String[] args) {
//获取Spring的上下文对象
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//我们的对象下能在都在spring·中管理了，我们要使用，直接取出来就可以了
Hello holle = (Hello) context.getBean("hello");
//此方式可以避免强转
//Hello holle = context.getBean("hello",Hello.class);
System.out.println(holle.toString());
}

}

ClassPathXmlApplicationContext继承树（ctrl+h）

image-20210407095011752

ClassPathXmlApplicationContext继承接口实现类（Ctrl+Alt+u）

image-20210407095604551

image-20210406214700035

通俗理解：
原来这套程序是：你写好菜单买好菜，客人来了自己把菜炒好招待，就相当于你请人吃饭
现在这套程序是：你告诉楼下餐厅，你要哪些菜，客人来的时候，餐厅把做好的你需要的菜送上来
IoC：炒菜这件事，不再由你自己来做，而是委托给了第三方__餐厅来做

此时的区别就是，如果我还需要做其他的菜，我不需要自己搞菜谱买材料再做好，而是告诉餐厅，我要什么菜，什么时候要，你做好送来

4. IoC创建对象的方式

方式一：使用无参构造创建对象（默认）
方式二：使用有参构造创建对象:下面介绍
实体类User

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package com.spring.pojo;

public class User {
    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    String name;
}

  • 下标赋值：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    <?xml 
    version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://www.springframework.org/schema/beans
           https://www.springframework.org/schema/beans/spring-beans.xsd">

       <bean id="user" class="pojo.User">
           <constructor-arg index="0" value="zjc"/>
       </bean>
    </beans>

    其中index指的是有参构造中参数的下标，下标从0开始

  • 类型赋值（不建议）

    1
    2
    3
    <bean id="user" class="pojo.User">
        <constructor-arg type="java.lang.String" value="zjc"/>
    </bean>

  • 直接通过参数名（掌握）

    1
    2
    3
    4
    <bean id="user" class="pojo.User">
        <constructor-arg name="name" value="zjc"></constructor-arg>
    </bean>
    <!-- 比如参数名是name，则有name="具体值" -->

总结：在配置文件加载的时候，容器(< bean>)中管理的对象就已经初始化了

5. Spring配置

5.1 别名

1
2
3
4
5
6
7
8
<bean id="user" class="pojo.User">
    <constructor-arg name="name" value="chen"></constructor-arg>
</bean>

<alias name="user" alias="userLove"/>
<!-- 使用时
User user2 = (User) context.getBean("userLove");
-->

5.2 Bean的配置

1
2
3
4
5
6
7
8
9
<!--id：bean的唯一标识符，也就是相当于我们学的对象名
class：bean对象所对应的会限定名：包名+类型
name：也是别名，而且name可以同时取多个别名 -->
<bean id="user" class="pojo.User" name="u1 u2,u3;u4">
    <property name="name" value="chen"/>
</bean>
<!-- 使用时
User user2 = (User) context.getBean("u1");
-->

name里面的分隔符可以是：空格 逗号 分号等

5.3 import

import一般用于团队开发使用，它可以将多个配置文件，导入合并为一个

假设，现在项目中有多个人开发，这三个人复制不同的类开发，不同的类需要注册在不同的bean中，我们可以利
用import将所有人的beans.xml合并为一个总的！

  • 张三(beans.xm1)

  • 李四(beans2.xm1)

  • 王五(beans3.xm1)

  • applicationContext.xml

    1
    2
    3
    <import resource="beans.xm1"/>
    <import resource="beans2.xml"/>
    <import resource="beans3.xm1"/>

使用的时候，直接使用总的配置就可以了
注：按照在总的xml中的导入顺序来进行创建，后导入的会重写先导入的，最终实例化的对象会是后导入xml中的那个

6 依赖注入（DI）

  • 依赖：bean对象的创建依赖于容器
  • 注入：bean对象中的所有属性，由容器来注入

6.1 构造器注入

参考4. Ioc创建对象的方式

6.2 set方式注入【重点】

6.2.1创建Student类 与 Address类

Address类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Address {

    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Address{" +
                "address='" + address + '\'' +
                '}';
    }
}

Student类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
package com.kuang.pojo;


import java.util.*;

public class Student {

  private String name;
  private Address address;

  private String[] books;
  private List<String> hobbies;

  private Map<String, String> card;
  private Set<String> game;

  private Properties infor;
  private String wife;

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public Address getAddress() {
    return address;
  }

  public void setAddress(Address address) {
    this.address = address;
  }

  public String[] getBooks() {
    return books;
  }

  public void setBooks(String[] books) {
    this.books = books;
  }

  public List<String> getHobbies() {
    return hobbies;
  }

  public void setHobbies(List<String> hobbies) {
    this.hobbies = hobbies;
  }

  public Map<String, String> getCard() {
    return card;
  }

  public void setCard(Map<String, String> card) {
    this.card = card;
  }

  public Set<String> getGame() {
    return game;
  }

  public void setGame(Set<String> game) {
    this.game = game;
  }

  public Properties getInfor() {
    return infor;
  }

  public void setInfor(Properties infor) {
    this.infor = infor;
  }

  public String getWife() {
    return wife;
  }

  public void setWife(String wife) {
    this.wife = wife;
  }

  @Override
  public String toString() {
    return "Student{" +"\n"+
      "name='" + name + '\'' +"\n"+
      ", address=" + address.toString() +"\n"+
      ", books=" + Arrays.toString(books) +"\n"+
      ", hobbies=" + hobbies +"\n"+
      ", card=" + card +"\n"+
      ", game=" + game +"\n"+
      ", infor=" + infor +"\n"+
      ", wife='" + wife + '\'' +"\n"+
      '}';
  }
}

6.2.2 配置beans.xml

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">
  <bean id="address" class="com.kuang.pojo.Address">
    <property name="address" value="啦啦啦"/>
  </bean>
  <bean id="student" class="com.kuang.pojo.Student">
    <!--第一种，普通值注入 -->
    <property name="name" value="name你好" />
    <!--第二种，ref注入 -->
    <property name="address" ref="address" />

    <!--数组注入 -->
    <property name="books">
      <array>
        <value>三国</value>
        <value>西游</value>
        <value>水浒</value>
      </array>
    </property>

    <!--list列表注入 -->
    <property name="hobbies">
      <list>
        <value>唱</value>
        <value>跳</value>
        <value>rap</value>
        <value>篮球</value>
      </list>
    </property>

    <!--map键值对注入 -->
    <property name="card">
      <map>
        <entry key="username" value="root" />
        <entry key="password" value="root" />
      </map>
    </property>

    <!--set(可去重)注入 -->
    <property name="game">
      <set>
        <value>wangzhe</value>
        <value>lol</value>
        <value>galname</value>
      </set>
    </property>

    <!--空指针null注入 -->
    <property name="wife">
      <null></null>
    </property>

    <!--properties常量注入 -->
    <property name="infor">
      <props>
        <prop key="id">20200802</prop>
        <prop key="name">cbh</prop>
      </props>
    </property>
  </bean>

</beans>

其中 array list set 均为value单闭合标签
map与props比较特殊单独记忆

6.2.3 测试

1
2
3
4
5
6
7
8
9
10
11
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import pojo.Student;

public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student stu = (Student) context.getBean("student");
System.out.println(stu.toString());
}
}

6.3 拓展注入

使用p c命名空间

User类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package com.kuang.pojo;

public class User {
  private String name;
  private int id;
  public User() {

  }
  public User(String name, int id) {
    super();
    this.name = name;
    this.id = id;
  }
  public String getName() {
    return name;
  }
  public void setName(String name) {
    this.name = name;
  }
  public int getId() {
    return id;
  }
  public void setId(int id) {
    this.id = id;
  }
  @Override
  public String toString() {
    return "User [name=" + name + ", id=" + id + "]";
  }
}

使用p和c命名空间需要导入xml约束

xmlns:p=“http://www.springframework.org/schema/p”
xmlns:c=“http://www.springframework.org/schema/c”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--p命名空间注入/set注入，需要存在无参构造函数和对应的set方法 相当于 property-->
    <bean id="user" class="pojo.User" p:name="cxk" p:id="20" >
    </bean>

    <!--c命名空间，通过构造器注入，需要存在相应的构造函数 相当于 construct-args -->
    <bean id="user2" class="pojo.User" c:name="cbh" c:id="22"></bean>
</beans>

可以理解为：c->construct-args p->propertyg

官方解释为：

image-20210407184704274

6 Bean作用域

image-20210407185436834

只需要知道【单例模式】和【原型模式】就可以了
其余的request、session、application这些只能在web开放中使用！

6.1 单例模式

默认就是单例模式

1
<bean id="user2" class="pojo.User" c:name="cxk" c:age="19" scope="singleton"></bean>

image-20210407185653939

6.2原型模式

每次从容器中get的时候，都产生一个新对象！

1
<bean id="user2" class="pojo.User" c:name="cxk" c:age="19" scope="prototype"></bean>

image-20210407190138919

7. Bean的自动装配

自动装配是Spring满足bean依赖的一种方式
Spring会在上下文自动寻找，并自动给bean装配属性
在Spring中有三种装配的方式

  1. 在xml中显示配置

  2. 在java中显示配置

  3. 隐式的自动装配bean 【重要】

环境搭建：一个人有两个宠物

byType自动装配：byType会自动查找，和自己对象set方法参数的类型相同的bean

保证所有的class唯一(类为全局唯一)[如果没有set方法不会提示]

byName自动装配：byName会自动查找，和自己对象set对应的值对应的id

保证所有id唯一，并且和set注入的值一致[如果没有set方法不会提示]

1
2
3
4
<!-- 找不到id和多个相同class -->
<bean id="cat1" class="pojo.Cat"/>
<bean id="cat2" class="pojo.Cat"/>
<!-- 找不到 id=cat，且有两个Cat -->

7.1 测试自动装配

pojo的Cat类

1
2
3
4
5
public class Cat {
    public void shut(){
        System.out.println("miao");
    }
}

pojo的Dog类

1
2
3
4
5
6
public class Dog {

    public void shut(){
        System.out.println("wow");
    }
}

pojo的People类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package pojo;
public class People {
    
    private Cat cat;
    private Dog dog;
    private String name;

    public Cat getCat() {
        return cat;
    }

    public void setCat(Cat cat) {
        this.cat = cat;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "People{" +
                "cat=" + cat +
                ", dog=" + dog +
                ", name='" + name + '\'' +
                '}';
    }
}

xml配置 ->byType 自动装配

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="cat" class="pojo.Cat"/>
    <bean id="dog" class="pojo.Dog"/>
    
    <!--byType会在容器自动查找，和自己对象属性相同的bean
例如，Dog dog; 那么就会查找pojo的Dog类，再进行自动装配
-->
    <bean id="people" class="pojo.People" autowire="byType">
        <property name="name" value="cbh"></property>
    </bean>

</beans>

xml配置 ->byName 自动装配

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="cat" class="pojo.Cat"/>
<bean id="dog" class="pojo.Dog"/>
<!--byname会在容器自动查找，和自己对象set方法的set后面的值对应的id
  例如:setDog()，取set后面的字符作为id，则要id = dog 才可以进行自动装配
  
 -->
<bean id="people" class="pojo.People" autowire="byName">
<property name="name" value="cbh"></property>
</bean>
</beans>

byName只能匹配到小写

7.2 使用注解实现自动装配

1.导入context约束：
xmlns:context=”http://www.springframework.org/schema/context"

2.配置注解的支持：< context:annotation-config/>

1
2
3
4
5
6
7
8
9
10
11
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>
</beans>

7.2.1 @Autowired

默认是byType方式，如果匹配不上，就会byName
在属性上个使用，也可以在set上使用
我们可以不用编写set方法了，前提是自动装配的属性在Spring容器里，且要符合ByName 自动装配

1
2
3
4
5
6
7
public class People {
    @Autowired
    private Cat cat;
    @Autowired
    private Dog dog;
    private String name;
}

beans.xml文件

image-20210408103829751

Autowire源码

1
2
3
public @interface Autowired { 
boolean required() default true; 
}

如果定义了Autowire的require属性为false，说明这个对象可以为null，否则不允许为空（false表示找不到装配时不抛出异常）默认为true。

7.2.2 @Autowired+@Qualifier

@Autowired不能唯一装配时，需要@Autowired+@Qualifier

如果@Autowired自动装配环境比较复杂。自动装配无法通过一个注解完成的时候，可以使用@Qualifier(value = “dog”)去配合使用，指定一个唯一的id对象

1
2
3
4
5
6
7
8
public class People {
    @Autowired
    private Cat cat;
    @Autowired
    @Qualifier(value = "dog")
    private Dog dog;
    private String name;
}

如果xml文件中同一个对象被多个bean使用，Autowired无法按类型找到，可以用@Qualifier指定id查找

7.2.3 @Resource

默认是byName方式，如果匹配不上，就会byType

1
2
3
4
5
6
7
public class People {
    Resource(name="cat")
    private Cat cat;
    Resource(name="dog")
    private Dog dog;
    private String name;
}

Autowired是byType，@Autowired+@Qualifier = byType && byName

Autowired是先byteType,如果唯一則注入，否则byName查找。
resource是先byname,不符合再继续byType

7.2.4 @Autowired 与 @Resource的区别

  • 都是用来自动装配的，都可以放在属性字段上
  • @Autowired通过byType的方式实现，而且必须要求这个对象存在！（require默认为true）【常用】
  • @Resource默认通过byname的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！【常用】
  • 执行顺序不同：@Autowired默认通过byType的方式实现。@Resource默认通过byname的方式实现

8. 使用注解开发

在spring4之后，使用注解开发，必须要保证aop包的导入

在这里插入图片描述

使用注解需要导入contex的约束

1
2
3
4
5
6
7
8
9
10
11
12
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">

    <context:annotation-config/>

</beans>

8.1 bean

有了< context:component-scan>，另一个< context:annotation-config/>标签可以移除掉，因为已经被包含进去了。

1
2
3
4
<!--指定要扫描的包，这个包下面的注解才会生效
别只扫一个com.kuang.pojo包[范围如果大的话能覆盖到里面的包]--> 
<context:component-scan base-package="com.kuang"/> 
<context:annotation-config/>
1
2
3
4
5
6
//@Component 组件
//等价于<bean id="user" classs"pojo.User"/> 
@Component
public class User {  
     public String name ="zjc";
}

@Component ：组件，放在类上，说明这个类被spring管理了，这就是bean。

8.2 属性注入@Value

1
2
3
4
5
6
7
8
9
10
11
12
@Component
public class User { 
    //相当于<property name="name" value="kuangshen"/> 
    @Value("kuangshen") 
    public String name; 
    
    //也可以放在set方法上面
    //@Value("kuangshen")
    public void setName(String name) { 
        this.name = name; 
    }
}

8.3 衍生的注解

@Component有几个衍生注解，会按照web开发中，按照mvc三层架构分层。

  • dao （@Repository）
  • service（@Service）
  • controller（@Controller）

这四个注解的功能是一样的，都是代表将某个类注册到容器中

8.4 自动装配置

@Autowired：默认是byType方式，如果匹配不上，就会byName

@Nullable：字段标记了这个注解，说明该字段可以为空

@Resource：默认是byName方式，如果匹配不上，就会byType

8.5、作用域@Scope

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//原型模式prototype，单例模式singleton
//scope("prototype")相当于<bean scope="prototype"></bean>
@Component 
@Scope("prototype")
public class User { 
    
    //相当于<property name="name" value="kuangshen"/> 
    @Value("kuangshen") 
    public String name; 
    
    //也可以放在set方法上面
    @Value("kuangshen")
    public void setName(String name) { 
        this.name = name; 
    }
}

8.6、小结

xml与注解：

  • xml更加万能，维护简单，适用于任何场合
  • 注解，不是自己的类使用不了，维护复杂

最佳实践：

  • xml用来管理bean
  • 注解只用来完成属性的注入
  • 要开启注解支持

9 .使用java的方式配置Spring

不使用Spring的xml配置，完全交给java来做！
Spring的一个子项目，在spring4之后，它成为了核心功能

在这里插入图片描述

实体类User

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//这里这个注解的意思,就是说明这个类被Spring接管了,注册到了容器中 
//@Component 
public class User { 
    private String name;
    
    public String getName() { 
    return name; 
    } 
    //属性注入值
    @value("QINJIANG')  
    public void setName(String name) { 
    this.name = name; 
    } 
    @Override 
    public String toString() { 
        return "user{" + 
        "name='" + name + '\''+ 
        '}'; 
    } 
}

配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//这个也会Spring容器托管,注册到容器中,因为他本米就是一个@Component 
// @Configuration表这是一个配置类,就像我们之前看的beans.xml，类似于<beans>标签
//@Configuration 
//@ComponentScan("com.Kuang.pojo") //开启扫描
//@Import(KuangConfig2.class)
public class KuangConfig { 
    //注册一个bean , 就相当于我们之前写的一个bean 标签 
    //这个方法的名字,就相当于bean 标签中的 id 属性 ->getUser
    //这个方法的返同值,就相当于bean 标签中的class 属性 ->User
    
    //@Bean 
    public User getUser(){ 
    return new User(); //就是返回要注入到bean的对象! 
    } 
}

使用方式：

手动注册： @Bean

1
2
3
4
@Bean 
 public User getUser(){ 
 return new User(); //就是返回要注入到bean的对象! 
 }

这个方法的名字,就相当于bean 标签中的 id 属性 ->getUser
这个方法的返同值,就相当于bean 标签中的class 属性 ->User

  • 自动注入：@ComponentScan、@Component
  • 先开启扫描：@ComponentScan(“com.Kuang.pojo”) //开启扫描
    然后给相应实体类加上注解@Component

测试类

1
2
3
4
5
6
7
8
public class MyTest { 
    public static void main(String[ ] args) { 
    //如果完全使用了配置类方式去做,我们就只能通过 Annotationconfig 上下文来获取容器,通过配置类的class对象加载! 
    ApplicationContext context = new AnnotationConfigApplicationContext(KuangConfig.Class); //class对象
    User getUser =(User)context.getBean( "getUser"); //方法名getUser
    System.out.Println(getUser.getName()); 
    } 
}

10. 代理模式

为什么要学习代理模式，因为这就是SpringAOP的底层。

代理模式的分类：

  • 静态代理
  • 动态代理

image-20210409104454888

10.1 静态代理

在这里插入图片描述

image-20210409112039225

接口：

1
2
3
public interface Rent {
  public void rent();
}

真实角色：

1
2
3
4
5
6
7
package pojo;
public class HostMaster implements Host{
   
public void rent() {
System.out.println("房东要出租房子");
}
}

代理角色：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class Proxy implements Rent{

  public HostMaster host;

  public Proxy() {

  }

  public Proxy(HostMaster host) {
    super();
    this.host = host;
  }

  public void rent() {
    seeHouse();
    host.rent();
    fee();
    sign();
  }
  //看房
  public void seeHouse() {
    System.out.println("看房子");
  }
  //收费
  public void fee() {
    System.out.println("收中介费");
  }
  //合同
  public void sign() {
    System.out.println("签合同");
  }
}

4.客户访问代理角色

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Client {

  public static void main(String[] args) {
    //房东要出租房子
    HostMaster host = new HostMaster();
    //中介帮房东出租房子，但也收取一定费用（增加一些房东不做的操作）
    Proxy proxy = new Proxy(host);
    //看不到房东，但通过代理，还是租到了房子
    proxy.rent();

  }

}

聊聊aop：

image-20210409140904332

10.2 动态代理

动态代理和静态代理角色一样，动态代理底层是反射机制

动态代理类是动态生成的，不是我们直接写好的！

动态代理(两大类)：基于接口，基于类

  • 基于接口：JDK的动态代理

  • 基于类：cglib

  • java字节码实现：javasisit

了解两个类
1、Proxy：代理
2、InvocationHandler：调用处理程序

1.抽象角色

1
2
3
4
public interface Host {
public void rent();

}

2.真实角色

1
2
3
4
5
public class HostMaster implements Host{
public void rent() {
System.out.println("房东要租房子");
}
}

3.代理角色

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//我们会用这个类，自动生成代理类！
public class ProxyInvocationHandler implements InvocationHandler {
    //被代理的接口
    private Rent rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }

    //生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                rent.getClass().getInterfaces(),this);
    }

    //处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质，就是使用反射机制实现！
        Object result = method.invoke(rent, args);
        seeHose();
        fee();
        return result;
    }

    public void seeHose(){
        System.out.println("中介带着看房子！");
    }

    public void fee(){
        System.out.println("中介收取费用！");
    }
}

4.用户类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Client {
    public static void main(String[] args) {
        //真实角色
        Host host = new Host();

        //代理角色：现在没有
        ProxyInvocationHandler pih = new ProxyInvocationHandler();

        //通过调用程序处理角色来处理我们要调用的接口对象！
        pih.setRent(host);
        Rent proxy = (Rent) pih.getProxy(); //这里的proxy就是动态生成的，我们并没有写
        proxy.rent();

    }
}

在此，我们可以提炼出ProxyInvocationHandler作为工具类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//用这个类自动生成代理类！
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //生成得到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }

    //处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }

    public void log(String msg){
        System.out.println("[Debug] 使用了一个"+msg+"方法");
    }
}

动态代理的好处：

  • 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
  • 公共角色就交给代理角色！实现了业务的分工！
  • 公共业务发生扩展的时候，方便集中管理！
  • 一个动态代理类代理的是一个接口，一般就是对应的一类业务
  • 一个动态代理类可以代理多个类，只要是实现了同一个接口即可！

11、AOP

11.1 什么是AOP

AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

在这里插入图片描述

11.2 AOP在Spring中的作用

提供声明式事务；允许用户自定义切面

横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等…
切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
目标（Target）：被通知对象。
代理（Proxy）：向目标对象应用通知之后创建的对象。
切入点（PointCut）：切面通知执行的“地点”的定义。
连接点（JointPoint）：与切入点匹配的执行点。

在这里插入图片描述

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice：

在这里插入图片描述

即AOP在不改变原有代码的情况下，去增加新的功能。

11.3 使用Spring实现AOP

【重点】使用AOP织入，需要导入一个依赖包！

1
2
3
4
5
6
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

方式一： 使用Spring的API接口【主要是SpringAPI接口实现】

  1. 在service包下，定义UserService业务接口和UserServiceImpl实现类
1
2
3
4
5
6
public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("增加了一个用户！");
    }

    public void delete() {
        System.out.println("删除了一个用户！");
    }

    public void update() {
        System.out.println("更新了一个用户！");
    }

    public void select() {
        System.out.println("查询了一个用户！");
    }
}

2.在log包下，定义我们的增强类，一个Log前置增强和一个AfterLog后置增强类

1
2
3
4
5
6
7
8
9
public class Log implements MethodBeforeAdvice {

    //method: 要执行的目标对象的方法
    //args：参数
    //target：目标对象
    public void before(Method method, Object[] agrs, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}
1
2
3
4
5
6
7
public class AfterLog implements AfterReturningAdvice {

    //returnValue： 返回值
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);
    }
}

3.最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束，配置applicationContext.xml文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--注册bean-->
    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
    <bean id="log" class="com.kuang.log.Log"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>

    <!--方式一：使用原生Spring API接口-->
    <!--配置aop:需要导入aop的约束-->
    <aop:config>
        <!--切入点：expression：表达式，execution(要执行的位置！* * * * *)-->
        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>

        <!--执行环绕增加！-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

4.测试

1
2
3
4
5
6
7
8
9
10
11
public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        //动态代理代理的是接口：注意点
        UserService userService = (UserService) context.getBean("userService");

        userService.add();
//        userService.select();
    }
}

方式二： 自定义类来实现AOP【主要是切面定义】

  1. 在diy包下定义自己的DiyPointCut切入类
1
2
3
4
5
6
7
8
9
public class DiyPointCut {
    public void before(){
        System.out.println("======方法执行前======");
    }

    public void after(){
        System.out.println("======方法执行后======");
    }
}

2.去spring中配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
<!--方式二：自定义类-->
<bean id="diy" class="com.kuang.diy.DiyPointCut"/>

<aop:config>
    <!--自定义切面，ref 要引用的类-->
    <aop:aspect ref="diy">
        <!--切入点-->
        <aop:pointcut id="point" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
        <!--通知-->
        <aop:before method="before" pointcut-ref="point"/>
        <aop:after method="after" pointcut-ref="point"/>
    </aop:aspect>
</aop:config>

3.测试

同上

方式三： 使用注解实现！

  1. 在diy包下定义注解实现的AnnotationPointCut增强类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    //声明式事务！
    @Aspect //标注这个类是一个切面
    public class AnnotationPointCut {

        @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
        public void before(){
            System.out.println("====方法执行前====");
        }

        @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
        public void after(){
            System.out.println("====方法执行后====");
        }

        //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点；
        @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
        public void around(ProceedingJoinPoint jp) throws Throwable{
            System.out.println("环绕前");

            Signature signature = jp.getSignature();// 获得签名
            System.out.println("signature:"+signature);

            Object proceed = jp.proceed(); //执行方法

            System.out.println("环绕后");

            System.out.println(proceed);
        }

    }

2.在Spring配置文件中，注册bean，并增加支持注解的配置。

1
2
3
4
<!--方式三：使用注解-->
<bean id="annotationPointCut" class="com.kuang.diy.AnnotationPointCut"/>
<!--开启注解支持！ JDK(默认是 proxy-target-class="false")  cglib（proxy-target-class="true"）-->
<aop:aspectj-autoproxy/>

12 .整合mybatis

mybatis-spring官网：https://mybatis.org/spring/zh/
mybatis的配置流程：

  1. 编写实体类
  2. 编写核心配置文件
  3. 编写接口
  4. 编写Mapper.xmi
  5. 测试

12.1 mybatis-spring-方式一

  1. 编写数据源配置
  2. sqISessionFactory
  3. sqISessionTemplate（相当于sqISession）
  4. 需要给接口加实现类【new】
  5. 将自己写的实现类，注入到Spring中
  6. 测试！
  • 先导入jar包
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
<dependencies>

       <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
       <!--Spring-webMVC-->
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-webmvc</artifactId>
           <version>5.2.7.RELEASE</version>
       </dependency>

       <!--AOP-->
       <dependency>
           <groupId>org.aspectj</groupId>
           <artifactId>aspectjweaver</artifactId>
           <version>1.9.4</version>
       </dependency>

       <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
       <!--Spirng-jdbc-->
       <dependency>
           <groupId>org.springframework</groupId>
           <artifactId>spring-jdbc</artifactId>
           <version>5.2.7.RELEASE</version>
       </dependency>
       <!--mybatis-->
       <dependency>
           <groupId>org.mybatis</groupId>
           <artifactId>mybatis</artifactId>
           <version>3.5.2</version>
       </dependency>
       <!--mybatis-spring-->
       <dependency>
           <groupId>org.mybatis</groupId>
           <artifactId>mybatis-spring</artifactId>
           <version>2.0.4</version>
       </dependency>
       <!--mysql-->
       <dependency>
           <groupId>mysql</groupId>
           <artifactId>mysql-connector-java</artifactId>
           <version>8.0.12</version>
       </dependency>
       <!--lombok-->
       <dependency>
           <groupId>org.projectlombok</groupId>
           <artifactId>lombok</artifactId>
           <version>1.18.12</version>
       </dependency>
   </dependencies>

   <!--在build中配置resources，来防止资源导出失败的问题-->
   <!-- Maven解决静态资源过滤问题 -->
   <build>
       <resources>
           <resource>
               <directory>src/main/java</directory>
               <includes>
                   <include>**/*.properties</include>
                   <include>**/*.xml</include>
               </includes>
               <filtering>false</filtering>
           </resource>
           <resource>
               <directory>src/main/resources</directory>
               <includes>
                   <include>**/*.properties</include>
                   <include>**/*.xml</include>
               </includes>
               <filtering>false</filtering>
           </resource>
       </resources>
   </build>
  • 实体类
1
2
3
4
5
6
7
8

import lombok.Data;
@Data
public class User {
private int id;
private String name;
private String pwd;
}
  • 接口UserMapper
1
2
3
4
5
6
package mapper;
import java.util.List;
import pojo.User;
public interface UserMapper {
public List<User> getUser();
}
  • UserMapperImpl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package mapper;
import java.util.List;
import org.mybatis.spring.SqlSessionTemplate;
import pojo.User;

public class UserMapperImpl implements UserMapper{

//我们的所有操作，在原来都使用sqlSession来执行，现在都使用SqlSessionTemplate；
private SqlSessionTemplate sqlSessionTemplate;

//此处set方法是为了在Spring配置文件中注入属性时使用
public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
this.sqlSessionTemplate = sqlSessionTemplate;
}

public List<User> getUser() {
UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
return mapper.getUser();
}
}
  • UserMapper.xml
1
2
3
4
5
6
7
8
9
10
11
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
        
<!-- 绑定接口 -->
<mapper namespace="com.kuang.mapper.UserMapper">
<select id="getUser" resultType="com.kuang.pojo.User">
select * from mybatis.mybatis
</select>
</mapper>

resource目录下的 mybatis-config.xml、spring-dao.xml、applicationContext.xml

  • mybatis-config.xml（可以完全省略，在spring-dao中的sqlSessionFactory位置设置）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?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>
<!--开启日志-->
<settings>
<setting name="logImpl" value="STDOUT_LOGGING" />
</settings>

<!--可以给实体类起别名 -->
<typeAliases> 
<package name="pojo" />
</typeAliases>

</configuration>
  • spring-dao.xml（代替之前的MybatisUtils工具类）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">

  <!--DataSource:使用Spring的数帮源替换Mybatis的配置 其他数据源：c3p0、dbcp、druid
        这使用Spring提供的JDBC: org.springframework.jdbc.datasource -->
  <!--data source -->
  <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName"
              value="com.mysql.cj.jdbc.Driver" />
    <property name="url" value="jdbc:mysql:///mybatis?useUnicode=true&amp;characterEncoding=UTF-8&amp;userSSL=false&amp;serverTimezone=GMT%2B8"/>
    <property name="username" value="root" />
    <property name="password" value="123456" />
  </bean>

  <!--sqlSessionFactory-->
  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="datasource" />
    <!--绑定 mybatis 配置文件-->
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
    <property name="mapperLocations" value="classpath:com/kuang/mapper/*.xml"/>
  </bean>

  <!-- sqlSessionTemplate 就是之前使用的：sqlsession -->
  <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
    <!-- 只能使用构造器注入sqlSessionFactory 原因：它没有set方法-->
    <constructor-arg index="0" ref="sqlSessionFactory"/>
  </bean>

  <bean id="userMapper" class="com.kuang.mapper.UserMapperImpl">
      <property name="sqlSessionTemplate" ref="sqlSession"/>
  </bean>

</beans>
  • applicationContext.xml(导入spring-dao.xml)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
    
<!-- 导入spring-dao.xml -->
<import resource="spring-dao.xml"/>

    <bean id="userMapper" class="mapper.UserMapperImpl">
        <property name="sqlSessionTemplate" ref="sqlSession"></property>
    </bean>

</beans>
  • 测试
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import mapper.UserMapper;
import pojo.User;
public class MyTest {
public static void main(String[] args) {
        
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

//注意此处第二个参数只能填写UserMapperImpl.class，而不能写UserMapper.class
//UserMapperImpl userMapper = context.getBean("userMapper", UserMapperImpl.class);
UserMapper userMapper = (UserMapper) context.getBean("userMapper");

for (User user : userMapper.getUser()) {
System.out.println(user);
}
}
}

12.2 mybatis-spring-方式二

  • UserServiceImpl2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package mapper;
import pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.List;
//继承SqlSessionDaoSupport 类
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
    public List<User> getUser() {
        SqlSession sqlSession = getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.getUser();
        //或者一句话：return getSqlSession().getMapper(UserMapper.class).getUser();
    }
}
  • spring-dao.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">

  <!--DataSource:使用Spring的数帮源替换Mybatis的配置 其他数据源：c3p0、dbcp、druid
        这使用Spring提供的JDBC: org.springframework.jdbc.datasource -->
  <!--data source -->
  <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName"
              value="com.mysql.cj.jdbc.Driver" />
    <property name="url" value="jdbc:mysql:///mybatis?useUnicode=true&amp;characterEncoding=UTF-8&amp;userSSL=false&amp;serverTimezone=GMT%2B8"/>
    <property name="username" value="root" />
    <property name="password" value="123456" />
  </bean>

  <!--sqlSessionFactory-->
  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="datasource" />
    <!--绑定 mybatis 配置文件-->
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
    <property name="mapperLocations" value="classpath:com/kuang/mapper/*.xml"/>
  </bean>

  <!-- sqlSessionTemplate 就是之前使用的：sqlsession -->
  <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
    <!-- 只能使用构造器注入sqlSessionFactory 原因：它没有set方法-->
    <constructor-arg index="0" ref="sqlSessionFactory"/>
  </bean>

 
<!-- 方法二：SqlSessionTemplate 可以不写了-->

</beans>
  • applicationContext.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">

<import resource="spring-dao.xml" />

<!-- 方法二 -->
<bean id="userMapper2" class="mapper.UserMapperImpl2">
<property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
</bean>
</beans>
  • 测试
1
2
3
4
5
6
7
8
9
public class MyTest6 {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper userMapper = (UserMapper) context.getBean("userMapper2");
for (User user : userMapper.getUser()) {
System.out.println(user);
}
}
}

13. 声明式事务

  • 把一组业务当成一个业务来做；要么都成功，要么都失败！
  • 事务在项目开发中，十分的重要，涉及到数据的一致性问题
  • 确保完整性和一致性

事务的ACID原则：
1，原子性（atomic），事务由一个或多个行为捆绑在一起构成，好像是一个单独的工作单元。原子性保证事务内的操作要么都发生，要么都不发生。假如所有的操作都成功了，那么事务是成功的。加入任何一个操作失败，那么事务会进行回滚。

2，一致性（consistent），一旦一个事务结束了，不管成功还是失败，系统所处的状态和它的业务规则是一致的。也就是说，数据应当不会被破坏。

3，隔离性（isolation），事务应当允许多名用户操作同一个数据，一个用户的操作不会和其他用户的操作相混淆。因此，事务必须是隔离的，防止并行读写同一个数据的情况发生。注意，隔离通常意味着要锁定数据库的表或行。

4，持久性（durable），一旦事务完成，事务的结果应当持久化。这样不管什么样的系统崩溃，它们都能幸免于难。

声明式事务

先导入jar包，并没有新增的依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
<dependencies>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.7.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.9.4</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.2.7.RELEASE</version>
    </dependency>

    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>

    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.4</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.12</version>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
    </dependency>

</dependencies>

<!--在build中配置resources，来防止资源导出失败的问题-->
<!-- Maven解决静态资源过滤问题 -->
<build>
<resources>
    <resource>
        <directory>src/main/java</directory>
        <includes>
            <include>**/*.properties</include>
            <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
    </resource>
    <resource>
        <directory>src/main/resources</directory>
        <includes>
            <include>**/*.properties</include>
            <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
    </resource>
</resources>
</build>
  • pojo实体类User
1
2
3
4
5
6
7
8
9
10
11
12
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
private int id;
private String name;
private String pwd;
}
  • 接口UserMapper
1
2
3
4
5
6
7
8
9
10
11
import java.util.List;
import org.apache.ibatis.annotations.Param;
import pojo.User;

public interface UserMapper {
public List<User> getUser();

public int insertUser(User user); 

public int delUser(@Param("id") int id); 
}
  • UserMapperImpl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
import pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.List;

public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
    public List<User> getUser() {
    User user = new User(5,"你好","ok");
    insertUser(user);
    delUser(5);
        SqlSession sqlSession = getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.getUser();
        //或者return  getSqlSession().getMapper(UserMapper.class).getUser();
    }
    //插入
public int insertUser(User user) {
return getSqlSession().getMapper(UserMapper.class).insertUser(user);
}
//删除
public int delUser(int id) {
return getSqlSession().getMapper(UserMapper.class).delUser(id);
}
}
  • UserMapper.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!-- 绑定接口 -->
<mapper namespace="com.kuang.mapper.UserMapper">
  <select id="getUser" resultType="user">
select * from mybatis.user
</select>

  <insert id="insertUser"  parameterType="user" >
insert into  mybatis.user (id,name,pwd) values (#{id},#{name},#{pwd})
</insert>

  <delete id="delUser" parameterType="_int">
    delete from mybatis.user where id = #{id}
  </delete>

</mapper>
  • mybatis-config.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?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 -->
<configuration>

<!--开启日志-->
<settings>
<setting name="logImpl" value="STDOUT_LOGGING" />
</settings>

<!--可以给实体类起别名-->
<typeAliases> 
<package name="pojo" />
</typeAliases>

</configuration>
  • spring-dao.xml（已导入约束）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">


  <!--DataSource:使用Spring的数帮源替换Mybatis的配置 其他数据源：c3p0、dbcp、druid
        这使用Spring提供的JDBC: org.springframework.jdbc.datasource -->
  <!--data source -->
  <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName"
              value="com.mysql.cj.jdbc.Driver" />
    <property name="url" value="jdbc:mysql:///mybatis?useUnicode=true&amp;characterEncoding=UTF-8&amp;userSSL=false&amp;serverTimezone=GMT%2B8"/>
    <property name="username" value="root" />
    <property name="password" value="123456" />
  </bean>

  <!--sqlSessionFactory-->
  <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="datasource" />
    <!--绑定 mybatis 配置文件-->
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
    <property name="mapperLocations" value="classpath:com/kuang/mapper/*.xml"/>
  </bean>

  <!--声明式事务-->
  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <constructor-arg ref="datasource" />
  </bean>

  <!--结合aop实现事务织入-->
  <!--配置事务的通知类-->
  <tx:advice id="txAdvice" transaction-manager="transactionManager">
    <!--给哪些方法配置事务-->
    <!--新东西：配置事务的传播特性 propagation-->
    <tx:attributes>
      <tx:method name="add" propagation="REQUIRED"/>
      <tx:method name="delete" propagation="REQUIRED"/>
      <tx:method name="update" propagation="REQUIRED"/>
      <tx:method name="query" read-only="true"/>
      <!-- *号包含上面4个方法：
      <tx:method name="*" propagation="REQUIRED"/> -->
    </tx:attributes>
  </tx:advice>

  <!--配置事务切入-->
  <aop:config>
    <aop:pointcut id="txpointcut" expression="execution(* com.kuang.mapper.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="txpointcut"/>
  </aop:config>



</beans>

Spring中七种Propagation类的事务属性详解：

  1. REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择也是spring的默认选择。

  2. SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。

  3. MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。

  4. REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起。

  5. NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

  6. NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。

  7. NESTED：支持当前事务，如果当前事务存在，则执行一个嵌套事务，如果当前没有事务，就新建一个事务。

  • applicationContext.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">

<import resource="spring-dao.xml" />

<bean id="userMapper" class="mapper.UserMapperImpl">
<property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
</bean>
</beans>
  • 测试类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import mapper.UserMapper;
import pojo.User;
public class MyTest{
public static void main(String[] args) {

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

UserMapper userMapper = (UserMapper) context.getBean("userMapper");

for (User user : userMapper.getUser()) {
System.out.println(user);
}
}
}

注意：
UserMapperImpl中getUser()方法先插入一个user在删除一个user。
只有在同一次使用Sqlsession时事务才起作用。

上述文件主要看spring-dao最后那部分即可

]]> <h1 id="1-Spring"><a href="#1-Spring" class="headerlink" title="1.Spring"></a>1.Spring</h1> Win10环境+ CUDA9.0 +CUDNN7.0+TensorFlow1.7_1.6_1.5配置（亲测有效） http://yoursite.com/2020/05/24/Win10%E7%8E%AF%E5%A2%83+%20CUDA9.0%20+CUDNN7.0+TensorFlow1.7_1.6_1.5%E9%85%8D%E7%BD%AE%EF%BC%88%E4%BA%B2%E6%B5%8B%E6%9C%89%E6%95%88%EF%BC%89/ 2020-05-24T15:01:41.576Z 2021-10-17T17:34:53.156Z 前言：很多小伙伴在选择CUDA版本和cudnn版本上有疑问，这里简短的说一下，希望能帮到各位小伙伴，我在网上看到有人说，要根据自己的显卡来选择CUDA，其实是错误的，你可以下载自己所需要的CUDA版本,这只是个驱动而已。CUDA的版本和cundd的版本要对应，不然可能会有不兼容报错。CUDA是显卡驱动程序，cundd是用来加速深度学习训练的库，在训练网络时，使用GPU加速，会调CUDA驱动和cudnn库，安装时两者要联系起来，本文的第二步，就是做这个事。

系统环境：windows10 64位

显卡：GTX1060

CUDA版本:cuda_9.0.176_win10（配套的cudnn一定要是7版本）

下载地址：https://developer.nvidia.com/cuda-90-download-archive

CUDNN版本:cudnn-9.0-windows10-x64-v7（7版本的）

下载地址：https://developer.nvidia.com/cudnn

TensorFlow-gpu版本：TensorFlow1.7（1.6和1.5也支持）

1.下载CUDA, https://developer.nvidia.com/cuda-90-download-archive

按照自己机器的信息选择，下图是我自己机器信息：
在这里插入图片描述
下载完之后直接点击运行，会自行安装，安装时会让你选择一个文件夹作为抽取文件临时存放，记住这不是安装文件夹，安装文件夹系统会自动安装到C盘，具体我后面会提到，临时文件夹安装完后会自动删除。

2.下载cudnn,下载地址：https://developer.nvidia.com/cudnn，进去之后,找到对应的版本，点击Download，他会要你注册登录，然后填个问卷，才可以下载，这一步自行按照网站提示做就可以了。提交完问卷后，就可以点击下载了。以下是版本选择界面：

在这里插入图片描述
勾选这个，然后选择要下载的版本，我选的是图中划线那个（应该选择7.0版本，7.1可能有些不兼容）
在这里插入图片描述
在这里插入图片描述下载完，解压cudnn,会出现四个文件，如下：
在这里插入图片描述
接下来，我们要将CUDA和CUDNN链接起来，这样CUDA才能调用CUDNN.这里有两种方法将CUDA和CUDNN链接起来

第一种：

在环境变量下面，把解压后文件的bin目录加到系统环境变量中，放在path下面，如图：

在这里插入图片描述
重启一下电脑，让环境变量生效，完成。

第二种：

就是把cudnn中的库加入到CUDA中，因为CUDA系统会自动安装到c盘的Program Files文件中，选择该文件夹下的NVIDIA GPUComputing Toolkit文件，一直到
在这里插入图片描述这个文件夹下有如下文件，我标出的这三个，和cudnn中的前三个文件是对应的如下图：
在这里插入图片描述
接下来要做的就是，把cudnn三个文件夹中的文件，复制到CUDA相应文件夹的下面（仔细看一下就会发现他们的目录结构是一样的），完成。

3.安装TensorFlow

安装：在命令窗口中输入pip install tensorflow-gpu，

如果要安装（更新）最新的版本，可输入： pip install –upgrade tensorFlow-gpu

等待安装完成即可

4.现在CUDA,cudnn,TensorFlow都已经安装好了，可以尽情的去写TensorFlow代码啦！

（注：新手第一次使用TensorFlow-GPU版时，训练网络时应该在tf.session处做一点修改，如下：

将with tf.Session() as sess:

改为：

config = tf.ConfigProto()
config.gpu_options.allow_growth = True

with tf.Session(config=config) as sess:

否则可能会报错：
在这里插入图片描述
原因是当TensorFlow要大量使用GPU时，不会自动给其分配资源，需要手动调整。

）

]]> <p>前言：很多小伙伴在选择CUDA版本和cudnn版本上有疑问，这里简短的说一下，希望能帮到各位小伙伴，我在网上看到有人说，要根据自己的显卡来选择CUDA，其实是错误的，你可以下载自己所需要的CUDA版本,这只是个驱动而已。CUDA的版本和cundd的版本要对应，不然可能会有不兼容报错。CUDA是显卡驱动程序，cundd是用来加速深度学习训练的库，在训练网络时，使用GPU加速，会调CUDA驱动和cudnn库，安装时两者要联系起来，本文的第二步，就是做这个事。</p> 使用清华镜像快速下载TensorFlow各版本及已安装版本查看 http://yoursite.com/2020/05/24/%E4%BD%BF%E7%94%A8%E6%B8%85%E5%8D%8E%E9%95%9C%E5%83%8F%E5%BF%AB%E9%80%9F%E4%B8%8B%E8%BD%BDTensorFlow%E5%90%84%E7%89%88%E6%9C%AC%E5%8F%8A%E5%B7%B2%E5%AE%89%E8%A3%85%E7%89%88%E6%9C%AC%E6%9F%A5%E7%9C%8B/ 2020-05-24T14:59:05.471Z 2021-10-17T17:35:54.805Z 使用清华镜像快速下载TensorFlow各版本：

1
pip install tensorflow-gpu==1.12.0 -i https://pypi.tuna.tsinghua.edu.cn/simple #可改成任意版本
]]> <p>使用清华镜像快速下载TensorFlow各版本：</p> 用python不到3秒找出1亿以内的质数 http://yoursite.com/2020/05/24/%E7%94%A8python%E4%B8%8D%E5%88%B03%E7%A7%92%E6%89%BE%E5%87%BA1%E4%BA%BF%E4%BB%A5%E5%86%85%E7%9A%84%E8%B4%A8%E6%95%B0/ 2020-05-24T14:56:24.678Z 2021-10-17T17:36:59.267Z 下面是用python不到3秒找出1亿以内的质数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
# -*- coding: utf-8 -*-

import sys, time
import numpy as np

def find_prime(upper):
    """找出小于upper的所有质数"""
    
    prime_list = list()
    mid = int(np.sqrt(upper))
    nums = np.arange(upper)
    nums[1] = 0
    
    while True:
        primes = nums[nums>0]
        if primes.any():
            p = primes[0]
            prime_list.append(p)
            nums[p::p] = 0
            if p > mid:
                break
        else:
            break
    
    prime_list.extend(nums[nums>0].tolist())
    return prime_list

def fast_find_prime(upper, base=100000, block=20000000):
    """快速找出小于upper的所有质数"""
    
    if upper <= base:
        return find_prime(upper)
        
    mid = int(np.sqrt(upper))
    prime_list = find_prime(base)
    prime_array = np.array(prime_list)
    prime_array = prime_array[prime_array<=mid]
    
    start = base
    while start < upper:
        end = start + block
        if end > upper:
            end = upper
        print((start, end))
        
        prime_list.extend(process_func(start, np.copy(prime_array), (start, end)))
        start += block
    
    return prime_list


def process_func(id, primes, task_range):
    """执行分块任务的函数
    
    primes      - 用以剔除非质数的质数表
    task_range  - 分块任务的数值范围
    """
    
    nums = np.arange(task_range[0], task_range[1])
    for p in primes:
        k = (p-task_range[0]%p)%p
        nums[k::p] = 0
    
    return nums[nums>0].tolist()

upper = 100000000
t0 = time.time()
prime_list = fast_find_prime(upper)
t1 = time.time()
print('查找%d以内的质数耗时%0.3f秒，共找到%d个质数'%(upper, t1-t0, len(prime_list)))

在这里插入图片描述

]]> <p>下面是用python不到3秒找出1亿以内的质数</p> nodejs安装与配置 http://yoursite.com/2020/05/22/nodejs%E5%AE%89%E8%A3%85%E4%B8%8E%E9%85%8D%E7%BD%AE/ 2020-05-22T14:01:03.026Z 2021-10-17T17:38:13.687Z 1.下载对应的nodejs安装包

https://nodejs.org/en/download/
在这里插入图片描述
2.运行安装包，选择相关的路径，主要注意点如下选择add to path,因为这样会自动给你配置对应的环境变量，其余的都是直接下一步下一步然后install
在这里插入图片描述
3.检验是否安装成功，执行两个命令node -v 和npm -v(这个主要高版本的nodejs会在安装的过程中自动帮你安装的，主要的作用是对Node.js依赖的包进行管理，也可以理解为用来安装/卸载Node.js需要装的东西) 分别查看版本信息
在这里插入图片描述

]]> <p>1.下载对应的nodejs安装包</p> 如何发布文章到自己搭建的hexo博客上！ http://yoursite.com/2020/05/21/%E5%A6%82%E4%BD%95%E5%8F%91%E5%B8%83%E6%96%87%E7%AB%A0%E5%88%B0%E8%87%AA%E5%B7%B1%E6%90%AD%E5%BB%BA%E7%9A%84hexo%E5%8D%9A%E5%AE%A2%E4%B8%8A%EF%BC%81/ 2020-05-21T13:35:18.076Z 2021-10-17T17:39:30.610Z 下面是发布博客的两种方法

第一种方法

1.选择一个markdown编辑器，我觉得csdn自带的md编辑器就挺好用的，所以你可以注册一个csdn帐号，微信扫一扫就ok；
2.注册成功后登录进去，由于默认的是HTML编辑器，所以我们需要先修改下默认设置，首先找到右上角头像的位置，选择账号设置，然后如图选择我的博客
在这里插入图片描述
在这里插入图片描述
next 往下翻找到 默认编辑器类型：选择MarkDown编辑器 保存就ok了；
3.点击写博客，先了解下markdown编辑器基本的用法，然后就可以写博客了，写好之后导出到本地
在这里插入图片描述
如图，点击后选择MarkDown，会下载一个 .md 文件；然后找到这个md文件，把它复制到你hexo博客文件夹 中 source 下的 _posts 中，默认只有一个 hello-world.md；

  1. 复制完之后然后使用文本编辑器打开它，在第一行加上title，内容自定，如
1
title: this is my first blog

5.接着在你博客站点文件夹下右键空白处，选择Git Bash Here，输入 hexo g (完整命令为hexo generate)，用于生成静态文件
6 然后 输入 hexo s(完整命令为hexo server)，用于启动服务器，主要用来本地预览；完成后 打开浏览器输入 localhost:4000，会发现多了你刚写的那篇博客
7 最后输入hexo d(hexo deploy)，用于将本地文件发布到github等git仓库上；
8 好了，大功告成！

第二种方法

① 新建一个空文章，输入以下命令，会在项目 \Hexo\source_posts 中生成 文章标题.md 文件，文章标题根据需要命名

1
$ hexo n "文章标题"

也可以直接在 \Hexo\source_posts 目录下右键鼠标新建文本文档，改后缀为 .md 即可，这种方法比较方便

② 用编辑器编写文章

md 全称 Markdown， Markdown 是 2004 年由 John Gruberis 设计和开发的纯文本格式的语法，非常的简单实用，常用的标记符号屈指可数，几分钟即可学会， .md 文件可以使用支持 Markdown 语法的编辑器编辑，然后保存文件到 \Hexo\source_posts 文件夹下即可

推荐 Windows 上使用 MarkdownPad2 或者小书匠 编辑器，macOS 上使用 Mou 编辑器，Linux 上使用 Remarkable编辑器，Web 端上使用CSDN ，其他编辑器推荐可以参考我的另一篇文章：《最新主流 Markdown 编辑器推荐》

文章标题，标签，分类，封面图片，摘要等，可以在 Front-matter 里面配置（Front-matter 是文件最上方以 — 分隔的区域，用于指定个别文件的变量，官方文档：https://hexo.io/zh-cn/docs/front-matter ），举个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
---
layout: 页面布局（配合主题文档使用）
title: 文章名称
date: 文章日期
comments: 文章是否开启评论
photos: 文章封面图（仅部分主题支持）
tags: 
  - 文章标签一
  - 文章标签二
categories: 文章分类
description: 文章描述，即要在首页显示的摘要（仅部分主题支持）
---

这里是摘要

<!-- more -->

这里是正文

注意：description 和 <!-- more --> 方式显示摘要二选一即可，部分主题不支持description，每个配置英文冒号后面要空一格，不同主题配置有所差异，具体要参考主题文档

当我们用编辑器写好文章后，可以使用以下命令将其推送到服务器上

1
2
$ hexo g  
$ hexo d

或者将两个命令合二为一输入以下命令：

1
$ hexo d -g

现在访问你的博客就可以看见写好的文章啦！

]]> <p>下面是发布博客的两种方法</p> 使用 Github 和 Hexo 搭建自己的独立博客 http://yoursite.com/2020/05/20/%E4%BD%BF%E7%94%A8%20Github%20%E5%92%8C%20Hexo%20%E6%90%AD%E5%BB%BA%E8%87%AA%E5%B7%B1%E7%9A%84%E7%8B%AC%E7%AB%8B%E5%8D%9A%E5%AE%A2/ 2020-05-20T10:01:21.916Z 2021-10-17T13:39:09.027Z 我的博客地址：https://supremezjc.github.io

@TOC

● 入门

Github Pages
Github Pages可以被认为是用户编写的、托管在github上的静态网页。使用Github Pages可以为你提供一个免费的服务器，免去了自己搭建服务器和写数据库的麻烦。此外还可以绑定自己的域名。

Hexo
Hexo 是一个快速、简洁且高效的博客框架。Hexo 使用 Markdown（或其他渲染引擎）解析文章，在几秒内，即可利用靓丽的主题生成静态网页。

● 安装 Node.js

点击此处访问官网，按需下载相应版本，默认安装可以了。
如果不懂可以看我的另一篇文章
nodejs的安装和配置

在这里插入图片描述

● 安装 Git

点击此处访问官网，按需下载相应版本，默认安装即可

• 检验Git是否安装成功

同时按下 Win 键和 R 键打开运行窗口,输入 cmd ，然后输入以下命令，有相应版本信息显示则安装成功，若不正确可以卸载软件重新安装，此外若安装成功，在桌面右键鼠标，可以看到菜单里多了 Git GUI Here 和 Git Bash Here两个选项，第一个是图形界面的Git操作，另一个是命令行

1
2
3
$ git --version  
$ node -v  
$ npm -v

在这里插入图片描述
在这里插入图片描述

● 安装Hexo

选择一个磁盘，新建一个文件夹，自己重命名文件夹（如：我的文件夹为：Ｅ\TRHX_Blog），博客相关文件将储存在此文件夹下，在该文件夹下右键鼠标，点击 Git Bash Here，输入以下 npm 命令即可安装，第一个命令表示安装 hexo，第二个命令表示安装 hexo 部署到 git page 的 deployer，如图所示即为安装成功

1
2
$ npm install hexo-cli -g  
$ npm install hexo-deployer-git --save

在这里插入图片描述

• Hexo 初始化配置

在刚才新建的文件夹里面再次新建一个 Hexo 文件夹（如：我的文件夹为：E\TRHX_Blog\Hexo）,进入该 Hexo 文件夹右键鼠标，点击 Git Bash Here，输入以下命令，如图所示则安装成功

1
$ hexo init

在这里插入图片描述
Hexo 安装完成后，将会在指定文件夹中新建所需要的文件，Hexo 文件夹下的目录如下：
在这里插入图片描述

● 本地查看效果

执行以下命令，执行完即可登录 http://localhost:4000/ 查看效果

1
2
$ hexo generate  
$ hexo server

显示以下信息说明操作成功：

1
INFO Hexo is running at http://0.0.0.0:4000/. Press Ctrl+C to stop.

在这里插入图片描述

● 将博客部署到 Github Pages 上

到目前为止，我们的本地博客就成功搭建了，但是现在我们只能通过本地连接查看博客，我们要做的是让其他人也能够访问我们的博客，这就需要我们将博客部署到Github Pages上

• 注册 Github 账户

点击此处访问 Github 官网，点击 Sign Up 注册账户

• 创建项目代码库

点击 New repository 开始创建，步骤及注意事项见下图：

在这里插入图片描述

• 配置 SSH 密钥

只有配置好 SSH 密钥后，我们才可以通过 git 操作实现本地代码库与 Github 代码库同步，在你第一次新建的文件夹里面（如：我的文件夹为：Ｅ\TRHX_Blog） Git Bash Here 输入以下命令：

1
2
$ ssh-keygen -t rsa -C "your email@example.com" 
//引号里面填写你的邮箱地址，比如我的是1248164682.qq.com

之后会出现：

1
2
3
Generating public/private rsa key pair.  
Enter file in which to save the key (/c/Users/you/.ssh/id_rsa):  
//到这里可以直接回车将密钥按默认文件进行存储

然后会出现：

1
2
3
Enter passphrase (empty for no passphrase):  
//这里是要你输入密码，其实不需要输什么密码，直接回车就行 
Enter same passphrase again:

接下来屏幕会显示：

1
2
3
4
5
6
Your identification has been saved in /c/Users/you/.ssh/id_rsa.  
Your public key has been saved in /c/Users/you/.ssh/id_rsa.pub.  
The key fingerprint is:  
这里是各种字母数字组成的字符串，结尾是你的邮箱  
The key's randomart image is:  
这里也是各种字母数字符号组成的字符串

运行以下命令，将公钥的内容复制到系统粘贴板上

1
$ clip < ~/.ssh/id_rsa.pub

• 在 GitHub 账户中添加你的公钥

① 登陆 GitHub，进入 Settings：
在这里插入图片描述
② 点击 SSH and GPG Keys：
在这里插入图片描述
③ 选择 New SSH key：
在这里插入图片描述
④ 粘贴密钥：
在这里插入图片描述

• 测试

输入以下命令：注意：git@github.com不要做任何更改！

1
$ ssh -T git@github.com

之后会显示：
在这里插入图片描述
输入 yes 后会显示：
在这里插入图片描述

• 配置 Git 个人信息

Git 会根据用户的名字和邮箱来记录提交，GitHub 也是用这些信息来做权限的处理，输入以下命令进行个人信息的设置，把名称和邮箱替换成你自己的，名字可以不是 GitHub 的昵称，但为了方便记忆，建议与 GitHub 一致

1
2
$ git config --global user.name "此处填你的用户名"  
$ git config --global user.email  "此处填你的邮箱"

到此为止 SSH Key 配置成功，本机已成功连接到 Github

● 将本地的 Hexo 文件更新到 Github 的库中

① 登录 Github 打开自己的项目 your name.github.io
在这里插入图片描述
② 鼠标移到 Clone or download 按钮，选择 Use SSH
在这里插入图片描述
③ 一键复制地址
在这里插入图片描述
④ 打开你创建的 Hexo 文件夹（如：E:\TRHX_Blog\Hexo），右键用记事本（Notepad++或者VS code等都可以）打开该文件夹下的 _config.yml 文件
在这里插入图片描述
⑤ 按下图修改 _config.yml 文件并保存
在这里插入图片描述
⑥ 在 Hexo 文件夹下分别执行以下命令

1
2
$ hexo g  
$ hexo d

或者直接执行

1
$ hexo g -d

执行完之后会让你输入你的 Github 的账号和密码，如果此时报以下错误，说明你的 deployer 没有安装成功

1
ERROR Deployer not found: git

需要执行以下命令再安装一次：

1
npm install hexo-deployer-git --save

再执行 hexo g -d，你的博客就会部署到 Github 上了
⑦ 访问博客

你的博客地址：https://你的用户名.github.io，比如我的是：https://supemezjc.github.io ,现在每个人都可以通过此链接访问你的博客了。

在博客中发表文章和申请域名请看我的其他文章。
这里非常感谢这位博主：https://blog.csdn.net/qq_36759224/article/details/82121420
他写的非常详细。

]]> <p>我的博客地址：<a href="https://supremezjc.github.io" target="_blank" rel="noopener">https://supremezjc.github.io</a></p> 26 种不同的编程语言的 “Hello World” 程序 http://yoursite.com/2020/05/18/26%20%E7%A7%8D%E4%B8%8D%E5%90%8C%E7%9A%84%E7%BC%96%E7%A8%8B%E8%AF%AD%E8%A8%80%E7%9A%84%20%E2%80%9CHello%20World%E2%80%9D%20%E7%A8%8B%E5%BA%8F/ 2020-05-18T08:16:47.150Z 2021-10-17T17:40:02.113Z 下面是用26中计算机语言编写的”Hello World”

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
1. C
#include 

int main()
{
    printf("Hello, World");
    return(0);
}
2. C++
#include 
 
int main()
{
    std::cout << "Hello World";
    return 0;
}
3. C#
using System;
class Program
{
    public static void Main(string[] args)
    {
        Console.WriteLine("Hello, World");
    }
}
4. Bash
echo "Hello, World"
5. Basic
PRINT "Hello, World"
6. HTML
 Hello, World
7. Java
public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}
8. Clipper
? "Hello, World"
9. Delphi
program HelloWorld;
begin
  Writeln('Hello, World');
end.
10. CoffeeScript
console.log 'Hello, World'
11. MatLab
disp('Hello, World')
12. Julia
println("Hello, World")
13. JavaScript
document.write('Hello, World');
14. Logo
print [Hello, World]
15. jQuery
$("body").append("Hello, World");
16. Perl 5
print "Hello, World";
17. Pascal
program HelloWorld;
begin
  WriteLn('Hello, World');
end.
18. Objective-C
#import 
#import 
 
int main(void)
{
    NSLog(@"Hello, World");
    return 0;
}
19. Visual Basic .NET
Module Module1
    Sub Main()
        Console.WriteLine("Hello, World")
    End Sub
End Module
20. R
cat('Hello, World')
21. VBScript
MsgBox "Hello, World"
22. XSLT
      Hello, World
23. Processing
void setup(){
  println("Hello, World");
}
24. Ruby
puts "Hello, World"
25. Swift
print("Hello, World")
26. Python
print ("Hello, World")
]]> <p>下面是用26中计算机语言编写的”Hello World”</p> Hello World http://yoursite.com/2020/05/16/hello-world/ 2020-05-16T05:47:20.881Z 2021-10-17T17:40:21.992Z Welcome to Hexo! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.

Quick Start

Create a new post

1
$ hexo new "My New Post"

More info: Writing

Run server

1
$ hexo server

More info: Server

Generate static files

1
$ hexo generate

More info: Generating

Deploy to remote sites

1
$ hexo deploy

More info: Deployment

]]> <p>Welcome to <a href="https://hexo.io/" target="_blank" rel="noopener">Hexo</a>! This is your very first post. Check <a href="https://hexo.io/docs/" target="_blank" rel="noopener">documentation</a> for more info. If you get any problems when using Hexo, you can find the answer in <a href="https://hexo.io/docs/troubleshooting.html" target="_blank" rel="noopener">troubleshooting</a> or you can ask me on <a href="https://github.com/hexojs/hexo/issues" target="_blank" rel="noopener">GitHub</a>.</p>