springboot基础学习总结

1. Maven 搭建springboot

• pom.xml文件内容

  <?xml version="1.0" encoding="UTF-8"?>
  <project xmlns="http://maven.apache.org/POM/4.0.0"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
  
      <groupId>org.example</groupId>
      <artifactId>springbootdemo</artifactId>
      <version>1.0-SNAPSHOT</version>
      <!--父类 -->
      <parent>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-parent</artifactId>
          <version>1.3.3.RELEASE</version>
      </parent>
      <dependencies>
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-web</artifactId>
          </dependency>
          <!-- 引入freeMarker的依赖包. -->
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-freemarker</artifactId>
          </dependency>
  <!-- 引入数据库相关的依赖包. -->
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-jdbc</artifactId>
          </dependency>
          <dependency>
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
              <version>8.0.12</version>
          </dependency>
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-test</artifactId>
              <scope>test</scope>
          </dependency>
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-data-jpa</artifactId>
          </dependency>
          <dependency>
              <groupId>org.mybatis.spring.boot</groupId>
              <artifactId>mybatis-spring-boot-starter</artifactId>
              <version>1.1.1</version>
          </dependency>
          <!-- 引入分布式事务管理的依赖包. -->
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-jta-atomikos</artifactId>
          </dependency>
      </dependencies>
      <!-- 配置打包配置信息 -->
      <build>
          <plugins>
              <plugin>
                  <groupId>org.apache.maven.plugins</groupId>
                  <artifactId>maven-compiler-plugin</artifactId>
                  <configuration>
                      <source>1.8</source>
                      <target>1.8</target>
                  </configuration>
              </plugin>
              <plugin>
                  <groupId>org.springframework.boot</groupId>
                  <artifactId>spring-boot-maven-plugin</artifactId>
                  <configuration>
                      <mainClass>com.zsl.App</mainClass>
                  </configuration>
                  <executions>
                      <execution>
                          <goals>
                              <goal>repackage</goal>
                          </goals>
                      </execution>
                  </executions>
  
              </plugin>
          </plugins>
      </build>
  </project>
  

2. 建立基本的Spring项目

2.1 Hello spring

• Spring Hello程序

  package com.zsl.controller;
  
  import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
  
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RestController;
  
  
  /**
   * @author m1767
   */
  @EnableAutoConfiguration
  @RestController
  public class HelloController {
  
      @RequestMapping("/")
      public String hello(){
          return "hello";
      }
  }
  2.2 启动springboot 方式
  

2.2 启动springboot

• 运行springboot方式一:

  • 在HelloController 类中建立main函数

    package com.zsl.controller;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
    
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    
    /**
     * @author m1767
     */
    @EnableAutoConfiguration
    @RestController
    public class HelloController {
    
        @RequestMapping("/")
        public String hello(){
            return "hello";
        }
    
        public static void main(String[] args) {
            SpringApplication.run(HelloController.class,args);
        }
    }
    
    

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XRCgl2tk-1643130698624)(C:\Users\m1767\AppData\Roaming\Typora\typora-user-images\1643098709385.png)]

  • 但是上述运行方式只能执行一个Controller。对于一个完整的项目，这种方式无法启动整个项目，所以推荐第二种方式

  • 方式二：建立APP类，通过这个类运行整个项目

    package com.zsl;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.context.annotation.ComponentScan;
    
    /**
     * @author m1767
     */
    @ComponentScan(basePackages = {"com.zsl.controller"})//扫包，将javabean添加到容器里
    public class App {
    
        public static void main(String[] args) {
            SpringApplication.run(App.class,args);
        }
    }
    

2.3 访问静态资源

• 添加引用包

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

• 访问static资源

  • 新建static文件夹,静态资源放在该文件夹里面就好
  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nTebNk2P-1643130698626)(C:\Users\m1767\AppData\Roaming\Typora\typora-user-images\1643100030319.png)]
  • 浏览器输入localhost:8080/this.jpg,就可以查看到文件夹

• 访问html页面

  • 新建templates文件夹

  • [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-teTgo8ag-1643130698626)(C:\Users\m1767\AppData\Roaming\Typora\typora-user-images\1643100280421.png)]

  • 文件后缀名为ftl

  • controller层

  • package com.zsl.controller;
    
    import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.ResponseBody;
    
    import java.util.Map;
    
    /**
     * @author m1767
     */
    @Controller
    public class HtmlController {
    
        @RequestMapping("/indexController")
        public String index(){
            System.out.println("index");
            return "index";
        }
    }
    
    

  • 返回到字符串是视图名称，不需要后缀名（注解一定是Controller）

2.4 mybatis+springboot

• 导入依赖包

•                 <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-jdbc</artifactId>
          </dependency>
          <dependency>
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
              <version>8.0.12</version>
          </dependency>
  		<dependency>
              <groupId>org.mybatis.spring.boot</groupId>
              <artifactId>mybatis-spring-boot-starter</artifactId>
              <version>1.1.1</version>
          </dependency>
  

• 配置application.properties文件

• spring.datasource.url=jdbc:mysql://localhost:3306/spring?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC
  spring.datasource.username=root
  spring.datasource.password=123456
  spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
  

• 新建mapper包，新建UserMapper接口

• package com.zsl.mapper;
  
  import com.zsl.models.User;// 在models包的User模型类
  import org.apache.ibatis.annotations.Insert;
  import org.apache.ibatis.annotations.Param;
  import org.apache.ibatis.annotations.Select;
  
  /**
   * @author m1767
   */
  
  public interface UserMapper {
  
      /**
       * 通过名字查找用户
       * @param name
       * @return
       */
      @Select("SELECT * FROM USERS WHERE NAME = #{name}")
      User findByName(@Param("name") String name);
  
      /**
       * 插入数据
       * @param name
       * @param age
       * @return
       */
      @Insert("INSERT INTO USERS(NAME, AGE) VALUES(#{name}, #{age})")
      int insert(@Param("name") String name, @Param("age") Integer age);
  }
  
  

• Controller层代码

• package com.zsl.controller;
  
  import com.zsl.mapper.UserMapper;
  import com.zsl.models.User;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RestController;
  
  import java.util.HashMap;
  import java.util.Map;
  
  /**
   * @author m1767
   */
  @RestController
  public class UserController {
  
      @Autowired
      private UserMapper userMapper;
  
      @RequestMapping("/getUser")
      public Map<String, Object> getUser(String name){
          Map<String, Object> map = new HashMap<String, Object>();
          User user = userMapper.findByName(name);
          map.put("user",user);
          return map;
      }
  
      @RequestMapping("/insertUser")
      public String insertMap(String name,Integer age){
          userMapper.insert(name,age);
          return "success";
      }
  }
  
  

• 查询数据

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l7nFwvst-1643130698627)(C:\Users\m1767\AppData\Roaming\Typora\typora-user-images\1643106732010.png)]

2.5 jpa+springboot

• 导入依赖包

•                <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-jdbc</artifactId>
          </dependency>
          <dependency>
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
              <version>8.0.12</version>
          </dependency>
  		<dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-data-jpa</artifactId>
          </dependency>
  

• 新建实例类

• package com.zsl.entity;
  
  import javax.persistence.Column;
  import javax.persistence.Entity;
  import javax.persistence.GeneratedValue;
  import javax.persistence.Id;
  
  /**
   * @author m1767
   */
  @Entity(name = "users")
  public class UserEntity {
  
      @Id
      @GeneratedValue
      private Integer id;
  
      @Column
      private String name;
  
      @Column
      private Integer age;
  
      public Integer getId() {
          return id;
      }
  
      public String getName() {
          return name;
      }
  
      public Integer getAge() {
          return age;
      }
  
      public void setId(Integer id) {
          this.id = id;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public void setAge(Integer age) {
          this.age = age;
      }
  }
  
  

• 新建Dao层 UserDao

• package com.zsl.dao;
  
  import com.zsl.entity.UserEntity;
  import org.springframework.data.jpa.repository.JpaRepository;
  
  /**
   * @author m1767
   */
  public interface UserDao extends JpaRepository<UserEntity,Integer> {
  	
  }
  
  

• Controller层

• package com.zsl.controller;
  
  import com.zsl.dao.UserDao;
  import com.zsl.entity.UserEntity;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RestController;
  
  /**
   * @author m1767
   */
  @RestController
  public class JpaUserController {
  
  
      @Autowired
      private UserDao userDao;
  
      @RequestMapping("/jsp/getUser")
      public UserEntity getUser(Integer id){
          UserEntity userEntity = userDao.findOne(id);
          System.out.println(userEntity);
          return userEntity;
      }
  
      @RequestMapping("/jsp/insertUser")
      public String  getUser(String name,Integer age){
          UserEntity userEntity = new UserEntity();
          userEntity.setAge(age);
          userEntity.setName(name);
          userDao.save(userEntity);
          System.out.println(userEntity);
          return "success";
      }
  }
  
  

3. 多数据源

3.1 以 mybites 为例

3.1.1 向properties文件添加信息

spring.datasource.test1.driverClassName = com.mysql.cj.jdbc.Driver
spring.datasource.test1.url = jdbc:mysql://localhost:3306/spring?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC
spring.datasource.test1.username = root
spring.datasource.test1.password = 123456
spring.datasource.test.minPoolSize = 3
spring.datasource.test.maxPoolSize = 25
spring.datasource.test.maxLifetime = 20000
spring.datasource.test.borrowConnectionTimeout = 30
spring.datasource.test.loginTimeout = 30
spring.datasource.test.maintenanceInterval = 60
spring.datasource.test.maxIdleTime = 60
spring.datasource.test.testQuery = select 1

spring.datasource.test2.driverClassName = com.mysql.cj.jdbc.Driver
spring.datasource.test2.url = jdbc:mysql://localhost:3306/spring01?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC
spring.datasource.test2.username = root
spring.datasource.test2.password = 123456
spring.datasource.test2.minPoolSize = 3
spring.datasource.test2.maxPoolSize = 25
spring.datasource.test2.maxLifetime = 20000
spring.datasource.test2.borrowConnectionTimeout = 30
spring.datasource.test2.loginTimeout = 30
spring.datasource.test2.maintenanceInterval = 60
spring.datasource.test2.maxIdleTime = 60
spring.datasource.test2.testQuery = select 1

3.1.2 写mapper包

新建俩个包mapper01，mapper02 ，内容一致，名称不一样

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pJESC66y-1643130698628)(C:\Users\m1767\AppData\Roaming\Typora\typora-user-images\1643127578552.png)]

package com.zsl.mapper01;

import com.zsl.models.User;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

/**
 * @author m1767
 */

public interface UserMapper01 {

    /**
     * 通过名字查找用户
     * @param name
     * @return
     */
    @Select("SELECT * FROM USERS WHERE NAME = #{name}")
    User findByName(@Param("name") String name);

    /**
     * 插入数据
     * @param name
     * @param age
     * @return
     */
    @Insert("INSERT INTO USERS(NAME, AGE) VALUES(#{name}, #{age})")
    int insert(@Param("name") String name, @Param("age") Integer age);
}

3.1.3 添加数据源配置类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B4vVdSM1-1643130698628)(C:\Users\m1767\AppData\Roaming\Typora\typora-user-images\1643127227479.png)]

package com.zsl.datasources;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

/**
 * datasourceTest1， 写法固定，改一下bean里的name值就行，通过spring容器获取相应的类的时候，要输入正确的   类名@Qualifier("test1DataSource") DataSource dataSource test1DataSrouce是第一个方法bean注解里的name值，不可乱写。
 * @author m1767
 */
@Configuration
@MapperScan(basePackages = {"com.zsl.mapper01"}, sqlSessionFactoryRef = "test1SqlSessionFactory")
public class DataSourceTest1 {

    @Primary
    @Bean(name = "test1DataSource")
    @ConfigurationProperties(prefix = "spring.datasource.test1")
    public DataSource testDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Primary
    @Bean(name = "test1SqlSessionFactory")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("test1DataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean.getObject();
    }

    @Primary
    @Bean(name = "test1TransactionManger")
    public DataSourceTransactionManager testTransactionManager(@Qualifier("test1DataSource") DataSource dataSource) throws Exception {
        return new DataSourceTransactionManager(dataSource);
    }

    @Primary
    @Bean(name = "test1SqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("test1SqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}

package com.zsl.datasources;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

/**
 *test2
 *
 * @author m1767
 */
@Configuration
@MapperScan(basePackages = {"com.zsl.mapper02"},sqlSessionFactoryRef = "test2sqlSessionFactory")
public class DataSourceTest2 {

    @Bean(name = "test2DataSource")
    @ConfigurationProperties("spring.datasource.test2")
    public DataSource testDataSource(){
        return DataSourceBuilder.create().build();
    }

    @Bean(name = "test2sqlSessionFactory")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("test2DataSource") DataSource dataSource) throws Exception{
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean.getObject();
    }

    @Bean(name = "test2TransactionManger")
    public DataSourceTransactionManager testTransactionManager(@Qualifier("test2DataSource") DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean(name = "test3SqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("test2sqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception{
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}

3.1.4 APP

package com.zsl;


import com.zsl.datasources.DataSourceTest1;
import com.zsl.datasources.DataSourceTest2;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.orm.jpa.EntityScan;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

/**
 *  
 *只需要SprintBootAplication注解即可
 * @author m1767
 */
@SpringBootApplication
@MapperScan(basePackages = {"com.zsl.mapper"})
@EntityScan(basePackages = {"com.zsl.entity"})
@EnableJpaRepositories
public class App {

    public static void main(String[] args) {
        SpringApplication.run(App.class,args);
    }
}

4. 分布式事务

解决的问题： 假如现在有俩个数据源，test1，test2，在控制器的插入数据方法 添加事务注解，并在这个方法同时操作俩个数据源，但某一刻插入数据出现异常，但只有test1 回滚，test2照常插入，俩俩者不同步。因为test使用Primary注解了，所以被当做默认数据源，所以事务的回滚只对test1有效而test2无效。所以使用jta对多数据源进行事务的统一的管理

4.1 以mybites 为例

4.1.1 添加依赖

        <!-- 引入分布式事务管理的依赖包. -->
    <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jta-atomikos</artifactId>
        </dependency>
    </dependencies>

4.1.2 向properties文件添加信息

mysql.datasource.test1.driverClassName = com.mysql.cj.jdbc.Driver
mysql.datasource.test1.url = jdbc:mysql://localhost:3306/spring?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC
mysql.datasource.test1.username = root
mysql.datasource.test1.password = 123456
mysql.datasource.test1.minPoolSize = 3
mysql.datasource.test1.maxPoolSize = 25
mysql.datasource.test1.maxLifetime = 20000
mysql.datasource.test1.borrowConnectionTimeout = 30
mysql.datasource.test1.loginTimeout = 30
mysql.datasource.test1.maintenanceInterval = 60
mysql.datasource.test1.maxIdleTime = 60
mysql.datasource.test1.testQuery = select 1

mysql.datasource.test2.driverClassName = com.mysql.cj.jdbc.Driver
mysql.datasource.test2.url = jdbc:mysql://localhost:3306/spring01?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=UTC
mysql.datasource.test2.username = root
mysql.datasource.test2.password = 123456
mysql.datasource.test2.minPoolSize = 3
mysql.datasource.test2.maxPoolSize = 25
mysql.datasource.test2.maxLifetime = 20000
mysql.datasource.test2.borrowConnectionTimeout = 30
mysql.datasource.test2.loginTimeout = 30
mysql.datasource.test2.maintenanceInterval = 60
mysql.datasource.test2.maxIdleTime = 60
mysql.datasource.test2.testQuery = select 1

4.1.3 新建配置类

俩个数据源俩个配置类，内容一样

package com.zsl.automanager;

import org.springframework.boot.context.properties.ConfigurationProperties;

/**
 * 和properties文件的变量一致
 * @author m1767
 */

@ConfigurationProperties(prefix = "mysql.datasource.test1")
public class DataConfig1 {
    private String url;
    private String username;
    private String password;
    private int minPoolSize;
    private int maxPoolSize;
    private int maxLifetime;
    private int borrowConnectionTimeout;
    private int loginTimeout;
    private int maintenanceInterval;
    private int maxIdleTime;
    private String testQuery;

    public  String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public  String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public  String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getMinPoolSize() {
        return minPoolSize;
    }

    public void setMinPoolSize(int minPoolSize) {
        this.minPoolSize = minPoolSize;
    }

    public int getMaxPoolSize() {
        return maxPoolSize;
    }

    public void setMaxPoolSize(int maxPoolSize) {
        this.maxPoolSize = maxPoolSize;
    }

    public int getMaxLifetime() {
        return maxLifetime;
    }

    public void setMaxLifetime(int maxLifetime) {
        this.maxLifetime = maxLifetime;
    }

    public int getBorrowConnectionTimeout() {
        return borrowConnectionTimeout;
    }

    public void setBorrowConnectionTimeout(int borrowConnectionTimeout) {
        this.borrowConnectionTimeout = borrowConnectionTimeout;
    }

    public int getLoginTimeout() {
        return loginTimeout;
    }

    public void setLoginTimeout(int loginTimeout) {
        this.loginTimeout = loginTimeout;
    }

    public int getMaintenanceInterval() {
        return maintenanceInterval;
    }

    public void setMaintenanceInterval(int maintenanceInterval) {
        this.maintenanceInterval = maintenanceInterval;
    }

    public int getMaxIdleTime() {
        return maxIdleTime;
    }

    public void setMaxIdleTime(int maxIdleTime) {
        this.maxIdleTime = maxIdleTime;
    }

    public String getTestQuery() {
        return testQuery;
    }

    public void setTestQuery(String testQuery) {
        this.testQuery = testQuery;
    }
}

4.1.4 添加数据源配置类

test1数据源和test2数据源一样。由于jta统一管理事务，则不用写事务方法（只需要修改bean的name值和从spring容器中获取bean的名称）

package com.zsl.datasource;

import com.mysql.cj.jdbc.MysqlXADataSource;
import com.zsl.automanager.DataConfig1;
import com.zsl.automanager.DataConfig2;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.jta.atomikos.AtomikosDataSourceBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;
import java.sql.SQLException;

/**
 * @author m1767
 */
@Configuration
@MapperScan(basePackages = {"com.zsl.mapper01"},sqlSessionFactoryRef = "t1SsF")
public class Test1 {

    @Primary
    @Bean(name = "t1DS")
    public DataSource testDataSource(DataConfig1 dataConfig1) throws SQLException {
        // 交给jta管理数据源
        MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
        mysqlXaDataSource.setUrl(dataConfig1.getUrl());
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
        mysqlXaDataSource.setPassword(dataConfig1.getPassword());
        mysqlXaDataSource.setUser(dataConfig1.getUsername());
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);

        AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
        xaDataSource.setXaDataSource(mysqlXaDataSource);
        xaDataSource.setUniqueResourceName("testDataSource");

        xaDataSource.setMinPoolSize(dataConfig1.getMinPoolSize());
        xaDataSource.setMaxPoolSize(dataConfig1.getMaxPoolSize());
        xaDataSource.setMaxLifetime(dataConfig1.getMaxLifetime());
        xaDataSource.setBorrowConnectionTimeout(dataConfig1.getBorrowConnectionTimeout());
        xaDataSource.setLoginTimeout(dataConfig1.getLoginTimeout());
        xaDataSource.setMaintenanceInterval(dataConfig1.getMaintenanceInterval());
        xaDataSource.setMaxIdleTime(dataConfig1.getMaxIdleTime());
        xaDataSource.setTestQuery(dataConfig1.getTestQuery());
        return xaDataSource;
    }

    @Primary
    @Bean(name = "t1SsF")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("t1DS") DataSource dataSource)
            throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean.getObject();
    }

    @Primary
    @Bean(name = "testSqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(
            @Qualifier("t1SsF") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

4.1.5 APP添加注解

package com.zsl;

import com.zsl.automanager.DataConfig1;
import com.zsl.automanager.DataConfig2;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.orm.jpa.EntityScan;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

/**
 * @author m1767
 */

@SpringBootApplication

@EnableConfigurationProperties(value = {DataConfig1.class, DataConfig2.class})


//@MapperScan(basePackages = {"com.zsl.mapper"})
public class App {
    /**
     * 运行多个控制器
     * @param args
     */
    public static void main(String[] args) {
        SpringApplication.run(App.class,args);
    }
}

5. 全局异常捕获

package com.zsl.controller;

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;
import java.util.Map;

/**
 * 异常捕获
 * @author m1767
 */
@ControllerAdvice
public class ExceptionHandle {

    @ExceptionHandler(RuntimeException.class)
    @ResponseBody
    public Map<String, Object> resultError(){
        Map<String, Object> result = new HashMap<String, Object>();
        result.put("success",200);
        result.put("error",500);
        return result;
    }
}

6. 读取properties文件内容

• 读取属性并赋值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B5QupZ8Y-1643130698629)(C:\Users\m1767\AppData\Roaming\Typora\typora-user-images\1643130300490.png)]

• 设置属性和值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mGALNHSs-1643130698629)(C:\Users\m1767\AppData\Roaming\Typora\typora-user-images\1643130327736.png)]

7. 日志配置

7.1 新建log.properties文件

#log4j.rootLogger=CONSOLE,info,error,DEBUG
log4j.rootLogger=info,error,CONSOLE,DEBUG
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender     
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout     
log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n     
log4j.logger.info=info
log4j.appender.info=org.apache.log4j.DailyRollingFileAppender
log4j.appender.info.layout=org.apache.log4j.PatternLayout     
log4j.appender.info.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.info.datePattern='.'yyyy-MM-dd
log4j.appender.info.Threshold = info   
log4j.appender.info.append=true   
#log4j.appender.info.File=/home/admin/pms-api-services/logs/info/api_services_info
log4j.appender.info.File=/Users/dddd/Documents/testspace/pms-api-services/logs/info/api_services_info
log4j.logger.error=error  
log4j.appender.error=org.apache.log4j.DailyRollingFileAppender
log4j.appender.error.layout=org.apache.log4j.PatternLayout     
log4j.appender.error.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.error.datePattern='.'yyyy-MM-dd
log4j.appender.error.Threshold = error   
log4j.appender.error.append=true   
#log4j.appender.error.File=/home/admin/pms-api-services/logs/error/api_services_error
log4j.appender.error.File=/Users/dddd/Documents/testspace/pms-api-services/logs/error/api_services_error
log4j.logger.DEBUG=DEBUG
log4j.appender.DEBUG=org.apache.log4j.DailyRollingFileAppender
log4j.appender.DEBUG.layout=org.apache.log4j.PatternLayout     
log4j.appender.DEBUG.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.DEBUG.datePattern='.'yyyy-MM-dd
log4j.appender.DEBUG.Threshold = DEBUG   
log4j.appender.DEBUG.append=true   
#log4j.appender.DEBUG.File=/home/admin/pms-api-services/logs/debug/api_services_debug
log4j.appender.DEBUG.File=/Users/dddd/Documents/testspace/pms-api-services/logs/debug/api_services_debug

7.2 控制器中添加日志对象

package com.zsl.controller;

import com.zsl.mapper01.MapperTest01;
import com.zsl.mapper02.MapperTest02;
import com.zsl.model.User;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.validation.Valid;

/**
 * @author m1767
 */
@EnableAutoConfiguration
@RestController
public class MyByteUserController {
    private static Logger log = Logger.getLogger(MyByteUserController.class);
    @Autowired
    private MapperTest01 userDao;
    @Autowired
    private MapperTest02 userDao2;
    @Value("${baidu}")
    private String baidu;

    @RequestMapping("/query")
    public User findName(String name){
        return userDao.findByName(name);
    }

    @Transactional
    @RequestMapping("/insert")
    public String insert(String name,Integer age){
        userDao.insert(name,age);
        userDao2.insert(name,age);
        log.info("插入一条数据 "+name+" "+age);
        return "success";
    }

    @RequestMapping("/getMsg")
    public String getBaidu(){
        return baidu;
    }
}

8. 添加多环境

这些也可以是properties文件

• application-dev.yml（开发环境）
• application-test.yml（测试环境）
• application-uat.yml（预发布）
• application-pro.yml（生产环境）