Java架构学习（二十八）SpringBoot高级&整合多数据源&分布式事务jta+Automikos&整合Log4j&全局AOP&定时任务&异步调用&读取配置参数&多环境配置&yml打包发布

最新推荐文章于 2020-10-28 23:36:23 发布

李初新

最新推荐文章于 2020-10-28 23:36:23 发布

阅读量2k

点赞数

分类专栏： Java架构基础学习一

本文链接：https://blog.csdn.net/leeue/article/details/82255312

版权

Java架构基础学习一专栏收录该内容

53 篇文章 2 订阅

订阅专栏

SpringBoot高级

一、@SpringBootApplication用法

@SpringBootApplication作用：启动项目，整合常用注解，扫包作用。
扫包只能在当前同级包下。
整合了这三个注解：
@Configuration
@EnableAutoConfiguration
@ComponentScan

二、SpringBoot整合多数据源

SpringBoot整合多数据源：
    在一个项目中，有多个jdbc连接。

多数据源产生的问题：事务管理。

在实际项目中怎么样搭建多数据源？
答:1、通过分包结构：
    com.leeue.test001 -- 访问test001数据库
        dao
        service
    com.leeue.test002 -- 访问test00数据库
        dao
        service
   2、使用注解方式：
       com.leeue
           dao
           service
       class UserService{
           @datasourcetest001  自定义注解方式
           public void test001(){
           }
           @datasourcetest002
           public void test002(){
           }
       }

springBoot整合多数据源实现

@Primary：设置默认的数据源是那个，必须要有一个是默认数据源

通过注解的方式来实现多数据源整合

1、配置application.properties

# 整合mysql
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=12345
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

# SpringBoot整合多数据源
# 配置test01数据源
spring.datasource.test1.driverClassName = com.mysql.jdbc.Driver
spring.datasource.test1.url = jdbc:mysql://localhost:3306/test01?useUnicode=true&characterEncoding=utf-8
spring.datasource.test1.username = root
spring.datasource.test1.password = 12345
# 配置test02数据源
spring.datasource.test2.driverClassName = com.mysql.jdbc.Driver
spring.datasource.test2.url = jdbc:mysql://localhost:3306/test02?useUnicode=true&characterEncoding=utf-8
spring.datasource.test2.username = root
spring.datasource.test2.password = 12345

2、配置数据源test1 DataSource1Config.java

package com.leeue.datasource;

import javax.sql.DataSource;

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;

@Configuration // 注册到springboot容器中
@MapperScan(basePackages = "com.leeue.test01", sqlSessionFactoryRef = "test1SqlSessionFactory")
public class DataSource1Config {

    /**
     * 配置test01 数据源
     * @return
     */
    @Bean(name = "test1DataSource")
    @Primary
    @ConfigurationProperties(prefix = "spring.datasource.test1")
    public DataSource testDataSource() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 功能描述:(配置 test1 sql会话工厂)
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean(name = "test1SqlSessionFactory")
    @Primary
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("test1DataSource") DataSource dataSource)
            throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
//      bean.setMapperLocations(
//              new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/test1/*.xml"));
        return bean.getObject();
    }

    /**
     * 功能描述:(test1 事物管理)
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean(name = "test1TransactionManager")
    @Primary
    public DataSourceTransactionManager testTransactionManager(@Qualifier("test1DataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

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

}

配置数据源 test02 DataSource2Config.java

package com.leeue.datasource;

import javax.sql.DataSource;

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;

@Configuration // 注册到springboot容器中
@MapperScan(basePackages = "com.leeue.test02", sqlSessionFactoryRef = "test2SqlSessionFactory")
public class DataSource2Config {

    /**
     * 配置test01 数据源
     * @return
     */
    @Bean(name = "test2DataSource")
    @ConfigurationProperties(prefix = "spring.datasource.test2")
    public DataSource testDataSource() {
        return DataSourceBuilder.create().build();
    }

    /**
     * 功能描述:(配置 test2 sql会话工厂)
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean(name = "test2SqlSessionFactory")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("test2DataSource") DataSource dataSource)
            throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
//      bean.setMapperLocations(
//              new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/test2/*.xml"));
        return bean.getObject();
    }

    /**
     * 功能描述:(test2 事物管理)
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean(name = "test2TransactionManager")
    public DataSourceTransactionManager testTransactionManager(@Qualifier("test2DataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

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

}

这里写图片描述

三、SpringBoot整合事务

Spring事务分类：编程性事务、声明事务（xml方式和注解）

@Transactional 使用的是这个就会自动回滚

四、SpringBoot分布式事务

注意：
多数据源事务回滚，Spring的默认事务控制，只能绑定一个数据源，
因此当多个数据数据源时，同时配置多个事务控制只有一个会有作用，
因此当异常触发回滚时，只回滚第一个事务配置绑定的数据源的sql，
没有实现多数据源的异常回滚。


分布式事务进行管理jta+AutoCAD
对test01和test02数据源事务，注册到第三方（AutoCAD）
原理：两端提交协议、2pc

继承AutoCAD来管理分布式事务

配置新文件：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jta-atomikos</artifactId>
</dependency>

五、springBoot整合log4j

六、SpringBoot全局AOP拦截

package com.leeue.aop;

import java.util.Enumeration;

import javax.servlet.http.HttpServletRequest;

import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.leeue.controller.IndexController;

@Aspect
@Component
public class WebLogAspect {
    private static Logger logger = Logger.getLogger(IndexController.class);
    @Pointcut("execution(public * com.leeue.controller..*.*(..))")
    public void webLog() {
    }
    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
        // 接收到请求，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        // 记录下请求内容
        logger.info("URL : " + request.getRequestURL().toString());
        logger.info("HTTP_METHOD : " + request.getMethod());
        logger.info("IP : " + request.getRemoteAddr());
        Enumeration<String> enu = request.getParameterNames();
        while (enu.hasMoreElements()) {
            String name = (String) enu.nextElement();
            logger.info("name:{"+name+"},value:{"+request.getParameter(name)+"+}");
        }
    }
    @AfterReturning(returning = "ret", pointcut = "webLog()")
    public void doAfterReturning(Object ret) throws Throwable {
        // 处理完请求，返回内容
        logger.info("RESPONSE : " + ret);
    }
}

七、SpringBoot实现定时任务

package com.leeue.scheduled;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class ScheduledTasks {
    private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
    @Scheduled(fixedRate = 1000)
    public void reportCurrentTime() {
        System.out.println("现在时间：" + dateFormat.format(new Date()));
    }
}

App.java里面加上注解

@EnableScheduling // 启动任务调度

八、SpringBoot做异步调用

使用@Async实现异步调用

九、springBoot读取配置文件参数

application.properties里面定义
leeue=leeue.com.cn

调用：

    @Value("${leeue}")
    private String leeue;

    @ResponseBody
    @RequestMapping("/index")
    public String index() {
        log.info("######log4j打印日志开始");
        System.out.println("参数注入..."+leeue);
        return "index";
    }

十、SpringBoot多环境配置

什么是多环境配置？
答：在企业中分为不同的环境配置。
test --- 本地开发环境
sit ----测试环境
pre ---- 预生产环境
prd ---- 生产环境

需要什么环境在application.properties 里配置

    spring.profiles.active=sit

这里写图片描述

十一、SpringBoot修改端口号

配置：
server.port=8888 
server.context-path=/itmayiedu

十三、SpringBoot的配置文件 yml文件

创建application.yml   每个值后面要加空格  
server:
  port:  8090
  context-path: /itmayiedu

十四、SpringBoot打包发布

入库要定义好：

    <!-- 配置SpringBoot打包入口 -->
    <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>
                    <maimClass>com.leeue.App</maimClass>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>

            </plugin>
        </plugins>
    </build>