springboot 集成mysql集群 springboot集成mybatis过程

记录自己的学习的每一天，今天是idea创建spring boot +mybatis，希望能对你有帮助

1.打开IDEA

2.File  ==>  new  ==>  project  ,如图：

3.选择spring Initializr ==> 右边的Project SDK我选的是我已经安装的1.8版本,其他默认 ==> 点击next

4.填写Group （自己随意就行） ==> 填写 Artifact （也是自己随意就行，这个也是你的项目名） ==> 点击next   ，如图：

5.选择项目所需依赖（由于项目是springboot+mybatis的Java后台项目，因此需要勾上三个依赖） ==>  点击next  ，如图：

6.选择项目路径  ==> 点击finish ,如图：

创建出来的项目如图：

mybatis添加的依赖就是这两个：

<dependency>
<groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <scope>runtime</scope>
</dependency>
<dependency>
   <groupId>org.mybatis.spring.boot</groupId>
   <artifactId>mybatis-spring-boot-starter</artifactId>
   <version>2.1.3</version>
</dependency>

7.进入项目需要配置maven,不然项目没法导入你需要的jar包

点击 file=>setting,就会看到如下图，填上相应的内容即可

8.我们在配置mybatis时要加上连接池：

数据库连接池的主要操作如下：

（1）建立数据库连接池对象（服务器启动）。

（2）按照事先指定的参数创建初始数量的数据库连接（即：空闲连接数）。

（3）对于一个数据库访问请求，直接从连接池中得到一个连接。如果数据库连接池对象中没有空闲的连接，且连接数没有达到最大（即：最大活跃连接数），创建一个新的数据库连接。

（4）存取数据库。

（5）关闭数据库，释放所有数据库连接（此时的关闭数据库连接，并非真正关闭，而是将其放入空闲队列中。如实际空闲连接数大于初始空闲连接数则释放连接）。

（6）释放数据库连接池对象（服务器停止、维护期间，释放数据库连接池对象，并释放所有连接）

首先添加依赖：

<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.14</version>
</dependency>

9.接下来就是在spring boot的核心配置（Application.properties）文件去配置数据库和连接池：

#设置访问项目的路径
server.servlet.context-path=/cnGong

#数据库连接url
spring.datasource.url=jdbc:mysql://localhost:3306/alldemo?useUnicode=true&characterEncoding=utf8&useSSL=false&allowMultiQueries=true&serverTimezone=UTC
#数据库的用户名
spring.datasource.username=root
#数据库的密码
spring.datasource.password=327219
#alibaba的数据库连接池
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
#mysql的数据库驱动
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
#监控统计用的filter:stat
spring.datasource.filters=stat
#最大连接池数量
spring.datasource.maxActive=2
#初始化时建立物理连接的个数。初始化发生在显示调用init方法，或者第一次getConnection时
spring.datasource.initialSize=1
#获取连接时最大等待时间，单位毫秒
spring.datasource.maxWait=60000
#最小连接池数量
spring.datasource.minIdle=1
# Destroy线程会检测连接的间隔时间2
spring.datasource.timeBetweenEvictionRunsMillis=60000
#如果要连接池只根据minEvictableIdleTimeMillis进程逐出，那么需要将softMinEvictableIdleTimeMillis设置为负数（即最大值）
spring.datasource.minEvictableIdleTimeMillis=3000
#用来检测连接是否有效的sql，要求是一个查询语句
spring.datasource.validationQuery=select 'x'
#建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
spring.datasource.testWhileIdle=true
#申请连接时执行validationQuery检测连接是否有效,做了这个配置会降低性能
spring.datasource.testOnBorrow=false
#归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能
spring.datasource.testOnReturn=false
#是否缓存preparedStatement，也就是PSCache。PSCache对支持游标的数据库性能提升巨大，比如说oracle。在mysql下建议关闭。
spring.datasource.poolPreparedStatements=true
#要启用PSCache，必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true。在Druid中，不会存在Oracle下PSCache占用内存过多的问题，可以把这个数值配置大一些，比如说100
spring.datasource.maxPoolPreparedStatementPerConnectionSize=20

10,确定项目目录结构，按最普遍的分层代码目录结构，如图：

11.接下来需要写mybatis的配置类：

首先建立一个目录，config，再在config目录下建立一个mybatis配置类MybatisConfig:

@Configuration//这是配置类的注解
@MapperScan(basePackages = "com.gongrongfei.allDemo.dao")//用注解表示要去扫描的dao层
public class MybatisConfig extends BaseConfig {
    private static final String MAPPER_PATH = "mapper/*.xml";//这是映射文件的位置
    @Bean//产生一个方法bean，将bean交给spring 进行管理
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource)
            throws Exception {
        SqlSessionFactoryBean sfb = new SqlSessionFactoryBean();
        sfb.setDataSource(dataSource);
        PathMatchingResourcePatternResolver pathMatchingResourcePatternResolver = new PathMatchingResourcePatternResolver();
        String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX + MAPPER_PATH;
        sfb.setMapperLocations(pathMatchingResourcePatternResolver.getResources(packageSearchPath));
        SqlSessionFactory factory = sfb.getObject();
        factory.getConfiguration().setMapUnderscoreToCamelCase(true);
        return factory;
    }
}

12.接下来需要写事务配置类：

 需要在进行事物管理的方法上添加注解@Transactional，或者偷懒的话直接在类上面添加该注解，使得所有的方法都进行事物的管理，但是依然需要在需要事务管理的类上都添加，工作量比较大，我们可以用下面的方法：

1.首先我们得引入aop（面向切面编程），：

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-aop</artifactId>
</dependency>

1.新建事务配置类：

2.这是事务配置类的实现方法，我们利用AOP自动在方法上面加上事务，代码上面有注解，希望可以帮助你理解：

@Configuration
//@Aspect:作用是把当前类标识为一个切面供容器读取
@Aspect
public class TransactionAdviceConfig extends BaseConfig {
    //声明一个常量，需要拦截的方法-用切点语言来写
    private static final String AOP_POINTCUT_EXPRESSION = "execution(* com.gongrongfei.allDemo..service.*Service.*(..))";

    @Autowired
    private PlatformTransactionManager transactionManager;

    @Bean
    public TransactionInterceptor txAdvice() {

        RuleBasedTransactionAttribute txAttr_REQUIRED = new RuleBasedTransactionAttribute();
        txAttr_REQUIRED.setRollbackRules(Collections.singletonList(new RollbackRuleAttribute(Exception.class)));
        //设置事务的传播行为，TransactionDefinition.PROPAGATION_REQUIRED
        //当前有事务，就加入这个事务，没有事务，就新建一个事务
        txAttr_REQUIRED.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        //设置隔离级别，可重复读取
        //可重复读取是指在一个事务内，多次读同一个数据，在这个事务还没结束时，其他事务不能访问该数据(包括了读写)，这样就可以在同一个事务内两次读到的数据是一样的，因此称为是可重复读隔离级别
        //txAttr_REQUIRED.setIsolationLevel(TransactionDefinition.ISOLATION_REPEATABLE_READ);
        RuleBasedTransactionAttribute txAttr_REQUIREDNEW = new RuleBasedTransactionAttribute();
        txAttr_REQUIREDNEW.setRollbackRules(Collections.singletonList(new RollbackRuleAttribute(Exception.class)));
        //设置事务的传播行为，TransactionDefinition.PROPAGATION_REQUIRES_NEW
        //新建一个事务执行，如果当前有事务，就把当前的事务挂起
        txAttr_REQUIREDNEW.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);

        NameMatchTransactionAttributeSource source = new NameMatchTransactionAttributeSource();

        source.addTransactionalMethod("*", txAttr_REQUIRED);
        source.addTransactionalMethod("newTran*", txAttr_REQUIREDNEW);

        return new TransactionInterceptor(transactionManager, source);
    }

    @Bean
    public Advisor txAdviceAdvisor() {
        //声明一个aspectj切点
        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
        //设置需要拦截的方法
        pointcut.setExpression(AOP_POINTCUT_EXPRESSION);
        //在该切点，执行txAdvice()方法
        return new DefaultPointcutAdvisor(pointcut, txAdvice());
    }

}

接下来我们从controller => service => dao=> user.xml,的整个过程

我们在写功能时习惯都是先去，写user.xml,再到 dao 层，再到service层，再到 controller

13，首先在数据库里创建user表

14，首先，在mapper下面新建，user.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.gongrongfei.allDemo.dao.UserDao">
    <select id="selectUser"  resultType="com.gongrongfei.allDemo.entity.User">
    select id, name, age, sex, work, adress, education_background
    from user
  </select>



</mapper>

15，新建UserDao层接口：

public interface UserDao {
    List<User> selectUser();
}

16，新建实体类 User：

public class User {
    private String id;
    private String name;
    private int age;
    private String adress;
    private char sex;
    private String work;
    private String educationBackground;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAdress() {
        return adress;
    }

    public void setAdress(String adress) {
        this.adress = adress;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public String getWork() {
        return work;
    }

    public void setWork(String work) {
        this.work = work;
    }

    public String getEducationBackground() {
        return educationBackground;
    }

    public void setEducationBackground(String educationBackground) {
        this.educationBackground = educationBackground;
    }
}

17.新建UserService,

@Service
public class UserService {
    //将UserDao注入进来
    @Resource
    private UserDao userDao;
    public List<User> selectUser(){

        return userDao.selectUser();
    }
}

18.新建UserController类

//RestController,是@Controller+@ResponseBody
//如果需要返回JSON，XML或自定义mediaType内容到页面，则需要在对应的方法上加上@ResponseBody注解
@RestController
//指定访问Controller层的路径
@RequestMapping("/select")
public class UserController {
    //将service层注入进来
    @Resource
    private UserService userService;
    //指定访问某个方法的路径
    @GetMapping("/user")
    private List<User> selectUser(){
        return userService.selectUser();
    }
}

接下来我们用postMan测试一下：

这样我们的mybatis就搭建成功了