springboot sessionfactory_搭建SpringBoot环境（Mock）

一、什么是mock，mock作用

mock是一种测试手段，通过用来模拟不可控或者比较复杂的的请求结果（比如第三方的请求），通过请求参数控制，来达到自己期望的结果。通俗得讲就是通过参数控制接口返回的是自己想要的“伪数据”

二、mock服务设计

网上大都是通过js,jQuery实现的mock,这里重点说明后端服务的mock-模拟第三方服务。

1、设计前的分析考虑

（1）mock服务要尽量脱离业务服务，避免过度耦合。比如说在与第三方交互过程中肯定会存在与业务系统之间的业务或者数据之间的交互，mock应尽量做到接近真实，降低对业务系统的依赖。

（2）请求方式/触发方式：请求方式必须和业务中对于第三方的请求完全一致，比如header,body,url等；触发方式要能通过参数对返回结果进行控制，做到要什么返回什么。

（3）mock方式：我们在进行mock的时候，并不是替换第三方，更多的是替换后端服务，服务中对外提供的服务可能有多个，比如：https,dubbo,hession等。

2、数据处理

（1）、对于有影响业务连续性，后续需要使用的数据，还是要写入数据库

（2）、对于单次数据，对数据没有任何影响的数据，建议写在缓存中，比如redis,mongo等缓存中，最好记录缓存周期（避免数据过大）。

3、场景设计

根据业务需要，场景将包含接口式处理方式和页面是处理方式。接口式的不在多说，页面式的就是包括页面一并设计出假跳转，假显示数据，假回调跳转等。

三、框架搭建

在这里搭建框架，需要什么搭建什么，采用一步步搭建的方式

1、搭建SpringBoot基础框架

（1）

（2）选出自己可能需要的功能

（3）编写项目参数

group/artifact等参数

（4）配置

server:
  port: 8080
spring:
  application:
    name: qydmock
  datasource:
    jdbc-url: jdbc:mysql://localhost:3306/production?characterEncoding=utf8&useUnicode=true&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&connectTimeout=100
    username: ***
    password: ***
    driver-class-name: com.mysql.jdbc.Driver
  second-datasource:
    jdbc-url: jdbc:mysql://localhost:3306/newproduction?characterEncoding=utf8&useUnicode=true&zeroDateTimeBehavior=convertToNull&allowMultiQueries=true&connectTimeout=100
    username: ***
    password: ***
    driver-class-name: com.mysql.jdbc.Driver
  mybatis:
      type-aliases-package: com.kaiyuan.p2p.mock.jdbc.model
      mapper-locations: classpath:mapping/*/*.xml
  redis:
    database: 0
    host: 127.0.0.1
    port: 6379
    password:
    pool:
    jedis:
      pool:
        min-idle: 0
        max-idle: 10
        max-wait: -1
    timeout: 1000
  rabbitmq:
      qyd:
        host: 127.0.0.1
        port: 5672
        username: ***
        password: ***
        virtual-host: /
      glt:
        host: 127.0.0.1
        port: 5672
        username: ***
        password: ***
        virtual-host: /
logging:
  config: classpath:logback.xml

2、集成mybatis（Mysql）

代码如下：

package com.kaiyuan.p2p.mock.jdbc.config;
 
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.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
 
import javax.sql.DataSource;
 
/**
 * @Author:zsc
 * @Description:
 * @Date:Create in 15:50 2019/8/12
 * @Modified By:
 **/
//表示这个类为一个配置类
@Configuration
// 配置mybatis的接口类放的地方
@MapperScan(basePackages = "com.kaiyuan.p2p.mock.jdbc.mapper.qydproduction", sqlSessionFactoryRef = "qydProSqlSessionFactory")
public class QydproductionConfig {
 
    // 将这个对象放入Spring容器中
    @Bean(name = "qydProDataSource")
    // 表示这个数据源是默认数据源
    @Primary
    // 读取application.properties中的配置参数映射成为一个对象
    // prefix表示参数的前缀
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource getDateSource1() {
        return DataSourceBuilder.create().build();
    }
    @Bean(name = "qydProSqlSessionFactory")
    // 表示这个数据源是默认数据源
    @Primary
    // @Qualifier表示查找Spring容器中名字为test1DataSource的对象
    public SqlSessionFactory test1SqlSessionFactory(@Qualifier("qydProDataSource") DataSource datasource)
            throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(datasource);
        bean.setMapperLocations(
                // 设置mybatis的xml所在位置
                new PathMatchingResourcePatternResolver().getResources("classpath*:mapping/qydproduction/*.xml"));
        return bean.getObject();
    }
    //配置事务
    @Bean(name = "qydProTransactionManager")
    @Primary
    public DataSourceTransactionManager testTransactionManager(@Qualifier("qydProDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
 
    @Bean("qydProSqlSessionTemplate")
    // 表示这个数据源是默认数据源
    @Primary
    public SqlSessionTemplate test1sqlsessiontemplate(
            @Qualifier("qydProSqlSessionFactory") SqlSessionFactory sessionfactory) {
        return new SqlSessionTemplate(sessionfactory);
    }
}

当只有一个数据源的时候，使用springboot默认配置即可，这个配置是针对多个数据源；多个数据源的配置方式就是多生成几个上面的文件，但是只有一个默认数据源，所以其他数据源中的配置文件不要再使用@Primary；改配置的作用就是将数据库接口和sql的xml匹配，并且生成bean叫i给spring管理。

3、集成MQ(rabbitMq)

package com.kaiyuan.p2p.mock.rebbitmq.config;
 
import com.rabbitmq.client.AMQP;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.amqp.SimpleRabbitListenerContainerFactoryConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
 
/**
 * @Author:zsc
 * @Description:
 * @Date:Create in 10:48 2019/8/13
 * @Modified By:
 **/
@Configuration
public class RabbitMqConfiguration {
 
    @Bean(name = "qydConnectionFactory")
    @Primary
    public ConnectionFactory qydConnectionFactory(
        @Value("${spring.rabbitmq.qyd.host}") String host,
        @Value("${spring.rabbitmq.qyd.port}") int port,
        @Value("${spring.rabbitmq.qyd.username}") String username,
        @Value("${spring.rabbitmq.qyd.password}") String password,
        @Value("${spring.rabbitmq.qyd.virtual-host}") String virtualHost){
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(host);
        connectionFactory.setPort(port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost(virtualHost);
        return connectionFactory;
    }
 
    @Bean(name="qydRabbitTemplate")
    @Primary
    public RabbitTemplate firstRabbitTemplate(
            @Qualifier("qydConnectionFactory") ConnectionFactory connectionFactory){
        RabbitTemplate hospSyncRabbitTemplate = new RabbitTemplate(connectionFactory);
        //使用外部事物
        //ydtRabbitTemplate.setChannelTransacted(true);
        return hospSyncRabbitTemplate;
    }
 
    @Bean(name="qydContainerFactory")
    @Primary
    public SimpleRabbitListenerContainerFactory hospSyncFactory(
            SimpleRabbitListenerContainerFactoryConfigurer configurer,
            @Qualifier("qydConnectionFactory") ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        configurer.configure(factory, connectionFactory);
        return factory;
    }
 
 
    @Bean(name="gltConnectionFactory")
    public ConnectionFactory hPayConnectionFactory(
            @Value("${spring.rabbitmq.glt.host}") String host,
            @Value("${spring.rabbitmq.glt.port}") int port,
            @Value("${spring.rabbitmq.glt.username}") String username,
            @Value("${spring.rabbitmq.glt.password}") String password,
            @Value("${spring.rabbitmq.glt.virtual-host}") String virtualHost){
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();
        connectionFactory.setHost(host);
        connectionFactory.setPort(port);
        connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost(virtualHost);
        return connectionFactory;
    }
 
    @Bean(name="gltRabbitTemplate")
    public RabbitTemplate gltRabbitTemplate(
            @Qualifier("gltConnectionFactory") ConnectionFactory connectionFactory){
        RabbitTemplate hospSyncRabbitTemplate = new RabbitTemplate(connectionFactory);
        //使用外部事物
        //ydtRabbitTemplate.setChannelTransacted(true);
        return hospSyncRabbitTemplate;
    }
 
    @Bean(name="gltContainerFactory")
    public SimpleRabbitListenerContainerFactory hPayFactory(
            SimpleRabbitListenerContainerFactoryConfigurer configurer,
            @Qualifier("gltConnectionFactory") ConnectionFactory connectionFactory) {
        SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
        configurer.configure(factory, connectionFactory);
        return factory;
    }
 
    @Bean
    public Queue qydQuene(){
        return new Queue("qydQueneMock");
    }
 
    @Bean
    public Queue gltQueue(){
        return new Queue("gltQueneMock");
    }
 
}

个人建议，所有的基础ConnectionFactory(mysql/mq/redis)尽量采用以上方式，因为随着Springboot版本不同或者引入的插件的版本不同，一些配置在application,yml中的映射已经法神了改变。并且在配置时一定要配置quene,之前没有配置quene一直发不出消息，但是也不会报错，加上quene后就能在可视化页面看到结果。

测试类：

生产者

import org.junit.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
 
import javax.annotation.Resource;
import java.util.Date;
 
/**
 * @Author:zsc
 * @Description:
 * @Date:Create in 17:33 2019/8/13
 * @Modified By:
 **/
public class MqSendTest extends BaseTest {
    @Resource(name="qydRabbitTemplate")
    private RabbitTemplate qydRabbitTemplate;
    @Test
    public void sendTest(){
        String context = "hello1 " + new Date();
        System.out.println("Sender : " + context);
        qydRabbitTemplate.convertAndSend("qydQueneMock", context);
        qydRabbitTemplate.convertAndSend("gltQueneMock", context);
        try {
            Thread.sleep(1000*100000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
 
    @Resource(name="gltRabbitTemplate")
    private RabbitTemplate gltRabbitTemplate;
    @Test
    public void sendGltTest(){
        String context = "hello1 " + new Date();
        System.out.println("Sender : " + context);
        gltRabbitTemplate.convertAndSend("qydQueneMock", context);
        gltRabbitTemplate.convertAndSend("gltQueneMock", context);
    }
 
 
}

消费者：

import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
 
/**
 * @Author:zsc
 * @Description:
 * @Date:Create in 10:16 2019/8/14
 * @Modified By:
 **/
@Component
@RabbitListener(queues = "qydQueneMock", containerFactory="qydContainerFactory")
public class MqReceiveServiceTest {
    @RabbitHandler
    public void process(String hello) {
        System.out.println("Receiver : " + hello);
    }
}

4、集成redis

package com.kaiyuan.p2p.mock.redis.config;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
 
/**
 * @Author:zsc
 * @Description:
 * @Date:Create in 16:50 2019/8/16
 * @Modified By:
 **/
@Configuration
public class RedisConfig extends CachingConfigurerSupport {
    /**
     * 注入 RedisConnectionFactory
     */
    @Autowired
    RedisConnectionFactory redisConnectionFactory;
 
 
    /**
     * 配置redisTemplate
     *
     * 通过redisConnectionFactory引入redis在配置文件中的连接配置
     * */
    @Bean
    public RedisTemplate<String,Object> redisTemplate(){
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
        return redisTemplate;
    }
 
    /**
     * 设置数据存入 redis 的序列化方式
     *
     * @param redisTemplate
     * @param factory
     */
    private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
//        redisTemplate.setHashValueSerializer(new StringRedisSerializer());
//        redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
//        redisTemplate.setHashValueSerializer(new Jackson2JsonRedisSerializer<Object>(Object.class));
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
        redisTemplate.setConnectionFactory(factory);
    }
 
 
    /**
     * 实例化 HashOperations 对象,可以使用 Hash 类型操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }
 
    /**
     * 实例化 ValueOperations 对象,可以使用 String 操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForValue();
    }
}

redis工具类：

package com.kaiyuan.p2p.mock.user.util;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
 
/**
 * @Author:zsc
 * @Description:
 * @Date:Create in 15:59 2019/8/16
 * @Modified By:
 **/
@Service
public class RedisUtil {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
 
    public Long lpush(String key, String value){
        Long res =  redisTemplate.opsForList().leftPush(key,value);
        System.out.println(res);
        return res;
    }
}

三、日志文件（log4j）

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- %m输出的信息,%p日志级别,%t线程名,%d日期,%c类的全名,%i索引【从数字0开始递增】,,, -->
    <!-- appender是configuration的子节点，是负责写日志的组件。 -->
    <!-- ConsoleAppender：把日志输出到控制台 -->
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d %p (%file:%line)- %m%n</pattern>
            <!-- 控制台也要使用UTF-8，不要使用GBK，否则会中文乱码 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>
    <!-- RollingFileAppender：滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件 -->
    <!-- 以下的大概意思是：1.先按日期存日志，日期变了，将前一天的日志文件名重命名为XXX%日期%索引，新的日志仍然是sys.log -->
    <!--             2.如果日期没有发生变化，但是当前日志的文件大小超过1KB时，对当前日志进行分割 重命名-->
    <appender name="syslog"
              class="ch.qos.logback.core.rolling.RollingFileAppender">
        <File>/opt/qyd/mock/log/mock.log</File>
        <!-- rollingPolicy:当发生滚动时，决定 RollingFileAppender 的行为，涉及文件移动和重命名。 -->
        <!-- TimeBasedRollingPolicy： 最常用的滚动策略，它根据时间来制定滚动策略，既负责滚动也负责出发滚动 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 活动文件的名字会根据fileNamePattern的值，每隔一段时间改变一次 -->
            <!-- 文件名：log/sys.2017-12-05.0.log -->
            <fileNamePattern>/opt/qyd/mock/log/credit.%d.%i.log</fileNamePattern>
            <!-- 每产生一个日志文件，该日志文件的保存期限为30天 -->
            <maxHistory>360</maxHistory>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <!-- maxFileSize:这是活动文件的大小，默认值是10MB,本篇设置为1KB，只是为了演示 -->
                <maxFileSize>10MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
        <encoder>
            <!-- pattern节点，用来设置日志的输入格式 -->
            <pattern>
                %d %p (%file:%line)- %m%n
            </pattern>
            <!-- 记录日志的编码 -->
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
    </appender>
    <!-- 控制台输出日志级别 -->
    <root level="info">
        <appender-ref ref="STDOUT"/>
    </root>
    <!-- 指定项目中某个包，当有日志操作行为时的日志记录级别 -->
    <!-- shop.bangke.credit为根包，也就是只要是发生在这个根包下面的所有日志操作行为的权限都是DEBUG -->
    <!-- 级别依次为【从高到低】：FATAL > ERROR > WARN > INFO > DEBUG > TRACE  -->
    <logger name="com.kaiyuan.p2p.mock" level="DEBUG">
        <appender-ref ref="syslog"/>
    </logger>
    <!--<logger level="DEBUG">-->
    <!--<appender-ref ref="syslog"/>-->
    <!--</logger>-->
</configuration>

注：以上配置都要和application.yml结合配置

四、maven打包

到此步骤，项目在maven启动时没有任何问题的，但是把项目拿到其他环境，发现mvn clean install打的包在启动的时候没有把application.yml打进去，所以pom.xml添加以下配置

<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
        <resources>
            <resource>
                <directory>srcmainresources</directory>
            </resource>
        </resources>
    </build>

没有启动类的model不需要使用plugins中的内容。

完成！

————————————————

原文链接：https://blog.csdn.net/Theo9/article/details/98945091

作者：金融研发中心 轻易贷研发二部-赵少超