20.1.从零开始学springboot-搭建一个可以上线的项目结构-单项目篇（1）

最新推荐文章于 2022-04-01 22:12:51 发布
最新推荐文章于 2022-04-01 22:12:51 发布
阅读量133 收藏
点赞数
原文链接：https://my.oschina.net/u/3066875/blog/3055367
版权

前言

通过前面的多章学习，相信大家对于springboot整合各个基础依赖已经得心应手了。并且，对于各个依赖的选择和使用都有了一定的理解。本章，将对前段时间的所学做一个总结，会完成一个可以上生产的项目基础架构。 首先，我们来归纳一下一般项目的需求：

  • 多数据源
  • 多数据源分布式事务
  • druid数据源监控
  • 数据持久层
  • 缓存
  • 日志记录

以上需求基本囊括了所有项目的基础。那么我们，根据需求，对应我们的前几章所学，不难得出springboot+mybatis+多数据源+druid+atomikos+redis+log的搭配，另外，项目多环境的情况，还必须提供切换环境的配置。为了解决mybatis写entity个mapper.xml文件麻烦的问题，我们需要引入自动生成插件mybatis-generator。

创建空项目

1.png

添加依赖

<!-- 引入依赖 start -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.16</version>
        </dependency>
        <!-- 添加对jta事务支持的依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jta-atomikos</artifactId>
        </dependency>
        <!-- mysql 8.0+ 对druid 1.1.10 xa事务支持有问题,so 两个都用release版解决问题 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.11</version>
        </dependency>
        <!-- 谷歌工具包 -->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>18.0</version>
        </dependency>
        <!-- 添加对aop支持的依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <!-- 添加对redis支持的依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-redis</artifactId>
            <version>1.4.7.RELEASE</version>
        </dependency>
        <!-- 引入依赖 end -->

4.png

完善plugin信息

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>

            <!-- mybatis generator 自动生成代码插件 -->
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.2</version>
                <configuration>
                    <!-- 对应generator配置文件的路径 -->
                    <configurationFile>src/main/resources/generator/masterGenerator.xml</configurationFile>
                    <!--<configurationFile>src/main/resources/generator/slaveGenerator.xml</configurationFile>-->
                    <overwrite>true</overwrite>
                    <verbose>true</verbose>
                </configuration>
            </plugin>
        </plugins>
    </build>

5.png

添加配置

application.yml：

## 公共配置start
## 配置数据源相关信息
spring:
  ## 环境配置
  profiles:
    active: dev
  ## 数据源设置
  datasource:
    type: com.alibaba.druid.pool.xa.DruidXADataSource
    druid:
      ## 连接池配置
      master:
        ## JDBC配置
        name: master
        url: jdbc:mysql://192.168.145.131:3306/test?useUnicode=true&characterEncoding=UTF-8&useSSL=false&autoReconnect=true&failOverReadOnly=false&serverTimezone=GMT%2B8
        username: root
        password: 123456
        driver-class-name: com.mysql.cj.jdbc.Driver
        filters: stat
        maxActive: 20
        initialSize: 1
        maxWait: 60000
        minIdle: 1
        timeBetweenEvictionRunsMillis: 60000
        minEvictableIdleTimeMillis: 300000
        validationQuery: select 'x'
        testWhileIdle: true
        testOnBorrow: true
        testOnReturn: true
        poolPreparedStatements: true
        maxOpenPreparedStatements: 20
      slave:
        ## JDBC配置
        name: slave
        url: jdbc:mysql://192.168.145.131/test2?useUnicode=true&characterEncoding=UTF-8&useSSL=false&autoReconnect=true&failOverReadOnly=false&serverTimezone=GMT%2B8
        username: root
        password: 123456
        driver-class-name: com.mysql.cj.jdbc.Driver
        filters: stat
        maxActive: 20
        initialSize: 1
        maxWait: 60000
        minIdle: 1
        timeBetweenEvictionRunsMillis: 60000
        minEvictableIdleTimeMillis: 300000
        validationQuery: select 'x'
        testWhileIdle: true
        testOnBorrow: true
        testOnReturn: true
        poolPreparedStatements: true
        maxOpenPreparedStatements: 20

  redis:
    host: 127.0.0.1  # redis服务所在的地址
    port: 6379
    password:   # redis的密码默认为空
    pool:
      max-active: 8  #连接池最大连接数（使用负值表示没有限制）
      max-idle: 8  #连接池最大空闲数
      min-idle: 1  #连接池最小空闲数
      max-wait: 60000  #获取连接的超时等待事件
    timeout: 30000  #连接redis服务器的最大等待时间

  #druid监控页面用户名和密码
  druid:
    name: admin
    pass: admin

## 该配置节点为独立的节点
mybatis:
  mapper-locations: classpath:mapper/*/*.xml  # 注意：一定要对应mapper映射xml文件的所在路径
  type-aliases-package: com.mrcoder.sbmmultidbxmldruidatomikos.entity # 注意：对应实体类的路径
  configuration:
    map-underscore-to-camel-case: true

## 公共配置 end
---
## 开发环境配置
spring:
  profiles: dev
server:
  port: 8080
---
## 测试环境配置
spring:
  profiles: test
server:
  port: 8082
---
## 生产环境配置
spring:
  profiles: prod
server:
  port: 8084

建库

创建test、test2库 test：

CREATE TABLE `student` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `age` int(11) NOT NULL,
  `grade` int(11) NOT NULL,
  `name` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

test2:

CREATE TABLE `teacher` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `age` int(11) NOT NULL,
  `course` int(11) NOT NULL,
  `name` varchar(255) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

完善

目录结构 2.png3.png

根据目录结构，请自行创建package和class。

config/datasource/DataSourceConfig

package com.mrcoder.sbmmultidbxmldruidatomikos.config.datasource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
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 org.springframework.core.env.Environment;
import javax.sql.DataSource;
import java.util.Properties;
/**
 * 数据源配置类
 */
@Configuration
public class DataSourceConfig {
    @Autowired
    private Environment env;
    @Value("${spring.datasource.type}")
    private String dataSourceType;
    /**
     * 配置主数据源，多数据源中必须要使用@Primary指定一个主数据源
     * 其次DataSource里用的是DruidXADataSource ，而后注册到AtomikosDataSourceBean并且返回
     */
    @Primary
    @Bean(name = "masterDataSource")
    public DataSource masterDataSource() {
        AtomikosDataSourceBean ds = new AtomikosDataSourceBean();
        Properties prop = build(env, "spring.datasource.druid.master.");
        ds.setXaDataSourceClassName(dataSourceType);
        ds.setPoolSize(5);
        ds.setXaProperties(prop);
        return ds;
    }
    /**
     * 配置次数据源
     * 其次DataSource里用的是DruidXADataSource ，而后注册到AtomikosDataSourceBean并且返回
     */
    @Bean(name = "slaveDataSource")
    public DataSource slaveDataSource() {
        AtomikosDataSourceBean ds = new AtomikosDataSourceBean();
        Properties prop = build(env, "spring.datasource.druid.slave.");
        ds.setXaDataSourceClassName(dataSourceType);
        ds.setPoolSize(5);
        ds.setXaProperties(prop);
        return ds;
    }
    private Properties build(Environment env, String prefix) {
        Properties prop = new Properties();
        prop.put("name", env.getProperty(prefix + "name"));
        prop.put("url", env.getProperty(prefix + "url"));
        prop.put("username", env.getProperty(prefix + "username"));
        prop.put("password", env.getProperty(prefix + "password"));
        prop.put("driverClassName", env.getProperty(prefix + "driverClassName", ""));
        prop.put("filters", env.getProperty(prefix + "filters"));
        prop.put("maxActive", env.getProperty(prefix + "maxActive", Integer.class));
        prop.put("initialSize", env.getProperty(prefix + "initialSize", Integer.class));
        prop.put("maxWait", env.getProperty(prefix + "maxWait", Integer.class));
        prop.put("minIdle", env.getProperty(prefix + "minIdle", Integer.class));
        prop.put("timeBetweenEvictionRunsMillis",
                env.getProperty(prefix + "timeBetweenEvictionRunsMillis", Integer.class));
        prop.put("minEvictableIdleTimeMillis", env.getProperty(prefix + "minEvictableIdleTimeMillis", Integer.class));
        prop.put("validationQuery", env.getProperty(prefix + "validationQuery"));
        prop.put("testWhileIdle", env.getProperty(prefix + "testWhileIdle", Boolean.class));
        prop.put("testOnBorrow", env.getProperty(prefix + "testOnBorrow", Boolean.class));
        prop.put("testOnReturn", env.getProperty(prefix + "testOnReturn", Boolean.class));
        prop.put("poolPreparedStatements", env.getProperty(prefix + "poolPreparedStatements", Boolean.class));
        prop.put("maxOpenPreparedStatements", env.getProperty(prefix + "maxOpenPreparedStatements", Integer.class));
        return prop;
    }
}

config/datasource/MasterSqlSessionTemplateConfig

package com.mrcoder.sbmmultidbxmldruidatomikos.config.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.mybatis.spring.boot.autoconfigure.ConfigurationCustomizer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import javax.sql.DataSource;
/**
 * MasterSqlSessionTemplateConfig配置类
 */
@Configuration
//下面的sqlSessionTemplateRef 值需要和生成的SqlSessionTemplate bean name相同，如果没有指定name,那么就是方法名
@MapperScan(basePackages = {"com.mrcoder.sbmmultidbxmldruidatomikos.mapper.master"}, sqlSessionTemplateRef = "masterSqlSessionTemplate")
public class MasterSqlSessionTemplateConfig {
    @Value("${mybatis.mapper-locations}")
    private String mapper_location;
    @Value("${mybatis.type-aliases-package}")
    private String type_aliases_package;
    @Value("${mybatis.configuration.map-underscore-to-camel-case}")
    private boolean mapUnderscoreToCamelCase;
    //将MybatisConfig类中初始化的对象注入进来
    @Autowired
    private ConfigurationCustomizer customizer;
    private Logger logger = LoggerFactory.getLogger(MasterSqlSessionTemplateConfig.class);
    /**
     * 自定义sqlSessionFactory配置（因为没有用到MybatisAutoConfiguration自动配置类，需要手动配置）
     */
    @Bean
    public SqlSessionFactory masterSqlSessionFactory(@Qualifier("masterDataSource") DataSource dataSource) throws Exception {
        logger.info("mapper文件地址为：{}", mapper_location);
        //在基本的 MyBatis 中,session 工厂可以使用 SqlSessionFactoryBuilder 来创建。
        //而在 MyBatis-spring 中,则使用SqlSessionFactoryBean 来替代：
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        //如果重写了 SqlSessionFactory 需要在初始化的时候手动将 mapper 地址 set到 factory 中，否则会报错：
        //org.apache.ibatis.binding.BindingException: Invalid bound statement (not found)
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(mapper_location));
        //下面这个setTypeAliasesPackage无效，是mybatis集成springBoot的一个bug，暂时未能解决
        bean.setTypeAliasesPackage(type_aliases_package);
        org.apache.ibatis.session.Configuration configuration = new org.apache.ibatis.session.Configuration();
        logger.info("mybatis配置驼峰转换为：{}", mapUnderscoreToCamelCase);
        configuration.setMapUnderscoreToCamelCase(mapUnderscoreToCamelCase);
        //因为没有用mybatis-springBoot自动装配，所以需要手动将configuration装配进去，要不然自定义的map key驼峰转换不起作用
        customizer.customize(configuration);
        bean.setConfiguration(configuration);
        return bean.getObject();
    }
    /**
     * SqlSessionTemplate 是 SqlSession接口的实现类，是spring-mybatis中的，实现了SqlSession线程安全
     */
    @Bean
    public SqlSessionTemplate masterSqlSessionTemplate(@Qualifier("masterSqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        SqlSessionTemplate template = new SqlSessionTemplate(sqlSessionFactory);
        return template;
    }
}

config/datasource/SlaveSqlSessionTemplateConfig

package com.mrcoder.sbmmultidbxmldruidatomikos.config.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.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import javax.sql.DataSource;
/**
 * SlaveSqlSessionTemplateConfig配置类
 */
@Configuration
@MapperScan(basePackages = {"com.mrcoder.sbmmultidbxmldruidatomikos.mapper.slave"}, sqlSessionTemplateRef = "slaveSqlSessionTemplate")
public class SlaveSqlSessionTemplateConfig {
    @Value("${mybatis.mapper-locations}")
    private String mapper_location;
    @Bean
    public SqlSessionFactory slaveSqlSessionFactory(@Qualifier("slaveDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        //如果重写了 SqlSessionFactory 需要在初始化的时候手动将 mapper 地址 set到 factory 中，否则会报错：
        //org.apache.ibatis.binding.BindingException: Invalid bound statement (not found)
        bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(mapper_location));
        return bean.getObject();
    }
    @Bean
    public SqlSessionTemplate slaveSqlSessionTemplate(@Qualifier("slaveSqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        SqlSessionTemplate template = new SqlSessionTemplate(sqlSessionFactory);
        return template;
    }
}

config/datasource/TransactionManagerConfig

package com.mrcoder.sbmmultidbxmldruidatomikos.config.datasource;
import com.atomikos.icatch.jta.UserTransactionImp;
import com.atomikos.icatch.jta.UserTransactionManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.jta.JtaTransactionManager;
import javax.transaction.UserTransaction;
/**
 * 多数据源事务管理器配置类
 */
@Configuration
public class TransactionManagerConfig {
    /**
     * 分布式事务使用JTA管理，不管有多少个数据源只要配置一个 JtaTransactionManager
     * @return
     */
    @Bean
    public JtaTransactionManager transactionManager(){
        UserTransactionManager userTransactionManager = new UserTransactionManager();
        UserTransaction userTransaction = new UserTransactionImp();
        return new JtaTransactionManager(userTransaction, userTransactionManager);
    }
}

config/wrapper/CustomWrapper

package com.mrcoder.sbmmultidbxmldruidatomikos.config.wrapper;
import com.google.common.base.CaseFormat;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.wrapper.MapWrapper;
import java.util.Map;
/**
 * @Description: 自定义wrapper处理spring boot + mybatis返回结果为map时的key值转换为驼峰
 */
public class CustomWrapper extends MapWrapper {
    public CustomWrapper(MetaObject metaObject, Map<String, Object> map) {
        super(metaObject, map);
    }
    @Override
    public String findProperty(String name, boolean useCamelCaseMapping) {
        if (useCamelCaseMapping) {
            return CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, name);
        }
        return name;
    }
}

config/wrapper/MapWrapperFactory

package com.mrcoder.sbmmultidbxmldruidatomikos.config.wrapper;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.wrapper.ObjectWrapper;
import org.apache.ibatis.reflection.wrapper.ObjectWrapperFactory;
import java.util.Map;
/**
 * 实现接口 ObjectWrapperFactory,通过包装工厂来创建自定义的wrapper
 */
public class MapWrapperFactory implements ObjectWrapperFactory {
    @Override
    public boolean hasWrapperFor(Object object) {
        return object != null && object instanceof Map;
    }
    @Override
    public ObjectWrapper getWrapperFor(MetaObject metaObject, Object object) {
        return new CustomWrapper(metaObject, (Map) object);
    }
}

config/DruidConfig

package com.mrcoder.sbmmultidbxmldruidatomikos.config;
import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * 配置 Druid登陆配置（白名单等）
 */
@Configuration
public class DruidConfig {
    @Value("${spring.druid.name}")
    private String name;
    @Value("${spring.druid.pass}")
    private String pass;
    private Logger logger = LoggerFactory.getLogger(DruidConfig.class);
    /**
     * 配置 Druid控制台 白名单、黑名单、用户名、密码等
     * 访问地址  ip+port/projectContextPath/druid/index.html
     */
    @Bean
    public ServletRegistrationBean DruidStatViewServlet(){
        logger.info("servletRegistrationBean configure is starting...");
        //org.springframework.boot.context.embedded.ServletRegistrationBean提供类的进行注册.
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new StatViewServlet(),"/druid/*");
        //添加初始化参数
        servletRegistrationBean.addInitParameter("allow","*");
        servletRegistrationBean.addInitParameter("loginUsername", name);
        servletRegistrationBean.addInitParameter("loginPassword", pass);
        //是否可以重置
        servletRegistrationBean.addInitParameter("resetEnable","false");
        return servletRegistrationBean;
    }
    /**
     * 注册一个：filterRegistrationBean
     */
    @Bean
    public FilterRegistrationBean druidStatFilter2(){
        logger.info("filterRegistrationBean configure is starting...");
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean(new WebStatFilter());
        //添加过滤规则.
        filterRegistrationBean.addUrlPatterns("/*");
        //添加不需要忽略的格式信息.
       filterRegistrationBean.addInitParameter("exclusions","*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        return filterRegistrationBean;
    }
}

config/MybatisConfig

package com.mrcoder.sbmmultidbxmldruidatomikos.config;
import com.mrcoder.sbmmultidbxmldruidatomikos.config.wrapper.MapWrapperFactory;
import org.mybatis.spring.boot.autoconfigure.ConfigurationCustomizer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * mybatis配置类,将自定义的MapWrapperFactory覆盖默认的ObjectWrapperFactory
 */
@Configuration
public class MybatisConfig {
    private Logger logger = LoggerFactory.getLogger(MybatisConfig.class);
    @Bean
    public ConfigurationCustomizer mybatisConfigurationCustomizer() {
        logger.info("initialize the ConfigurationCustomizer....");
        return new ConfigurationCustomizer() {
            @Override
            public void customize(org.apache.ibatis.session.Configuration configuration) {
                configuration.setObjectWrapperFactory(new MapWrapperFactory());
            }
        };
    }
}

config/RedisConfig

package com.mrcoder.sbmmultidbxmldruidatomikos.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.mrcoder.sbmmultidbxmldruidatomikos.utils.redis.RedisUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Qualifier;
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.*;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
 * @redis 配置类
 */
@Configuration
public class RedisConfig {
    private Logger logger = LoggerFactory.getLogger(RedisConfig.class);
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(factory);
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSeial.setObjectMapper(om);
        // 值采用json序列化
        template.setValueSerializer(jacksonSeial);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());
        // 设置hash key 和value序列化模式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jacksonSeial);
        template.afterPropertiesSet();
        return template;
    }
    /**
     * 对hash类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }
    /**
     * 对redis字符串类型数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForValue();
    }
    /**
     * 对链表类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }
    /**
     * 对无序集合类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }
    /**
     * 对有序集合类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }
    /**
     * 使用上面初始化的RedisTemplate实例来初始化一个RedisUtil对象
     * ps:@Qualifier("redisTemplate") 可以不用加，如果存在RedisTemplate实例，spring会默认注入
     */
    @Bean
    public RedisUtil redisUtil(@Qualifier("redisTemplate") RedisTemplate redisTemplate) {
        RedisUtil redisUtil = new RedisUtil();
        redisUtil.setRedisTemplate(redisTemplate);
        return redisUtil;
    }
}

entity/master/Student

package com.mrcoder.sbmmultidbxmldruidatomikos.entity.master;
import java.io.Serializable;
public class Student implements Serializable {
    private Long id;
    private String name;
    private int age;
    private int grade;
    public Student() {
    }
    public Student(String name, int age, int grade) {
        this.name = name;
        this.age = age;
        this.grade = grade;
    }
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", grade=" + grade +
                '}';
    }
    public Long getId() {
        return id;
    }
    public void setId(Long 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 int getGrade() {
        return grade;
    }
    public void setGrade(int grade) {
        this.grade = grade;
    }
}

entity/slave/Teacher

package com.mrcoder.sbmmultidbxmldruidatomikos.entity.slave;
import java.io.Serializable;
public class Teacher implements Serializable {
    private Long id;
    private String name;
    private int age;
    private int course;
    public Teacher() {
    }
    public Teacher(String name, int age, int course) {
        this.name = name;
        this.age = age;
        this.course = course;
    }
    @Override
    public String toString() {
        return "Teacher{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", course='" + course + '\'' +
                '}';
    }
    public Long getId() {
        return id;
    }
    public void setId(Long 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 int getCourse() {
        return course;
    }
    public void setCourse(int course) {
        this.course = course;
    }
}

mapper/master/StudentMapper

package com.mrcoder.sbmmultidbxmldruidatomikos.mapper.master;
import com.mrcoder.sbmmultidbxmldruidatomikos.entity.master.Student;
import org.apache.ibatis.annotations.Select;
import java.util.List;
public interface StudentMapper {
    //    @Select("SELECT * FROM student")
    List<Student> getList();

    //    @Select("SELECT * FROM student WHERE id = #{id}")
    Student getById(Long id);

    //    @Insert("INSERT INTO student(age,grade,name) VALUES(#{age}, #{grade}, #{name})")
    Integer insert(Student student);

    //    @Update("UPDATE student SET name=#{name},age=#{age}, grade=#{grade} WHERE id =#{id}")
    Integer update(Student student);

    //    @Delete("DELETE FROM student WHERE id =#{id}")
    Integer delete(Long id);


    //注解方式，本项目不建议使用
    @Select("SELECT * FROM student")
    List<Student> getListByAnno();
}

mapper/master/TeacherMapper

package com.mrcoder.sbmmultidbxmldruidatomikos.mapper.slave;
import com.mrcoder.sbmmultidbxmldruidatomikos.entity.slave.Teacher;
import java.util.List;
public interface TeacherMapper {
    //    @Select("SELECT * FROM teacher")
    List<Teacher> getList();

    //    @Select("SELECT * FROM teacher WHERE id = #{id}")
    Teacher getById(Long id);

    //    @Insert("INSERT INTO teacher(age,course,name) VALUES(#{age}, #{course}, #{name})")
    void insert(Teacher teacher);

    //    @Update("UPDATE teacher SET name=#{name},age=#{age}, course=#{course} WHERE id =#{id}")
    void update(Teacher teacher);

    //    @Delete("DELETE FROM teacher WHERE id =#{id}")
    void delete(Long id);
}

受制于篇幅限制

请查看下章 从零开始学springboot-搭建一个可以上线的项目结构-单项目篇（2）

项目地址

https://github.com/MrCoderStack/SpringBootDemo/tree/master/sbm-multidb-xml-druid-atomikos

https://gitee.com/MrCoderStack/SpringBootDemo/tree/master/sbm-multidb-xml-druid-atomikos

请关注我的订阅号

订阅号.png

转载于:https://my.oschina.net/u/3066875/blog/3055367

chenkun2817
关注
从零开始学Spring Boot
05-21
从零开始学Spring Boot,没有积分的可以看博客：http://412887952-qq-com.iteye.com/ 【Spring Boot 系列博客】 0）前言【从零开始学Spring Boot】 : http://412887952-qq-com.iteye.com/blog/2291496 （1）spring boot起步之Hello World【从零开始学Spring Boot】: http://412887952-qq-com.iteye.com/blog/2291500 （2）Spring Boot返回json数据【从零开始学Spring Boot】 http://412887952-qq-com.iteye.com/blog/2291508 （15）Spring Boot使用Druid和监控配置【从零开始学Spring Boot】 http://412887952-qq-com.iteye.com/blog/2292362 16）Spring Boot使用Druid（编程注入）【从零开始学Spring Boot】 http://412887952-qq-com.iteye.com/blogs/2292376 （17）Spring Boot普通类调用bean【从零开始学Spring Boot】： http://412887952-qq-com.iteye.com/blog/2292388 ...... （35）Spring Boot集成Redis实现缓存机制【从零开始学Spring Boot】 http://412887952-qq-com.iteye.com/blog/2294942 更多查看博客：http://412887952-qq-com.iteye.com/
20.从零开始学springboot-搭建一个可以上线的项目结构-单项目篇
CTO技术的博客
04-29 454
前言 通过前面的多章学习，相信大家对于springboot整合各个基础依赖已经得心应手了。并且，对于各个依赖的选择和使用都有了一定的理解。本章，将对前段时间的所学做一个总结，会完成一个可以上生产的项目基础架构。 首先，我们来归纳一下一般项目的需求： 多数据源 多数据源分布式事务 druid数据源监控 数据持久层 缓存 日志记录 以上需求基本囊括了所有项目的基础。那么我们，根据需求，对应我们的前...
1.从零开始学springboot-概念原理篇
CTO技术的博客
03-14 701
背景 公司统一技术栈，博主转型java，博主几年前从事过java web（ssh） &amp;amp; 安卓开发，所以有一定的底子，奈何时间太久了，忘的差不多了，所以边学习边记录 技术栈对比 基于目前的现状，基本上没什么选择，spring全家桶。早期还有不少基于Struts1&amp;amp;Struts2的项目，但是因为著名的RCE（远程代码执行）漏洞导致大批开发者远离。当然，基于一些历史原因，Struts还是...
从零开始学Spring Boot视频
悟纤学院
05-24 2万+
【从零开始学Spring Boot】已经在ITeye进行发布了， 【Spring Boot系列博客】 0）前言【从零开始学Spring Boot】: http://412887952-qq-com.iteye.com/blog/2291496 （1）spring boot起步之Hello World【从零开始学Spring Boot】: http://4128
QuartusProgrammerSetup-20.1.0.711-windows.7z
11-18
这个"Quartus Programmer Setup-20.1.0.711-windows.7z"文件是一个针对Windows操作系统的压缩包，包含了Quartus Programmer的安装程序，版本号为20.1.0.711。 在IT行业中，FPGA（Field-Programmable Gate Array）是...
Python库 | fmriprep-20.1.0rc2-py3-none-any.whl
02-16
`fmriprep` 是由BIDS-Apps项目开发的，BIDS（Brain Imaging Data Structure）是一个标准化的数据组织方案，旨在简化神经影像学研究的数据管理和分析。通过遵循BIDS标准，研究者可以将他们的原始扫描数据以一致的方式...
pip-20.1-py2.py3-none-any.whl
05-04
pip-20.1-py2.py3-none-any.whl 为python官网下载的pip20版本包
PyPI 官网下载 | fmriprep-20.1.0rc2-py3-none-any.whl
01-05
资源来自pypi官网。 资源全名：fmriprep-20.1.0rc2-py3-none-any.whl
从零开始学Spring Boot(Spring Boot技术文档)
09-21
从零开始学Spring Boot(Spring Boot技术文档)
从零开始学Spring Boot.pdf
07-22
从零开始学Spring Boot.pdf从零开始学Spring Boot.pdf从零开始学Spring Boot.pdf从零开始学Spring Boot.pdf从零开始学Spring Boot.pdf从零开始学Spring Boot.pdf从零开始学Spring Boot.pdf从零开始学Spring Boot.pdf从零开始学Spring Boot.pdf从零开始学Spring Boot.pdf从零开始学Spring Boot.pdf
springboot项目架构
04-04
springboot项目架构。欢迎学习springboot开发的朋友看下
SpringBoot从零开始学习
从零开始的专栏
03-30 2780
什么是SpringBoot Spring 相当于Web项目中的静态路由功能，主要是实现业务逻辑，当UI层发生请求用来解析请求数据内容，并从数据层查询并解析Bean结构，然后返回给UI层数据。 SpringMVC 的底层 servlet的封装，但配置比较繁琐。 SpringBoot 是 依赖于 SpringMVC 项目整合 SpringBoot 包括 Spring 和 SpringMVC，...
从零开始学spring-boot（1）-Hello spring boot!
追梦者的专栏
10-29 818
第一次看到springboot的时候就被它惊艳到了，相信开发java web的都知道，我们想要实现访问浏览器，返回“Hello word”需要付出多少努力，不管是SSH还是springMVC，想要实现“Hello word”,繁杂的XML配置会让你抓耳挠腮，而springboot的出现解放了我们的配置，让我们可以快速的投身到业务中去。
19. Spring Boot 添加JSP支持【从零开始学Spring Boot】
热门推荐
悟纤学院
07-24 6万+
【来也匆匆，去也匆匆，在此留下您的脚印吧,转发点赞评论；      您的认可是我最大的动力，感谢您的支持】 这个部分比较复杂，所以单独创建一个工程来进行讲解；      大体步骤： （1）       创建Maven web project； （2）       在pom.xml文件添加依赖； （3）       配置application.properties支持jsp （4）
Springboot从零开始学习笔记（1）
说好的
10-26 161
打算先学Spring，再学boot，每天抽空学一点，两周内学完。 ——2021.10.22 ...
3. Spring Boot 从零开始学习
menergy
03-22 1652
1. Spring 的生态圈 Spring 官网地址：Spring | Homehttps://spring.io/ 进入官网首页，可以看到Spring能做什么： 1. Microservices： 微服务开发。把大型应用拆分成一个个微小的功能模块，每一个微小的功能模块就是一个微服务。 2. Reactive： 响应式编程。基于异步非阻塞的方式， 整个应用之间构建异步数据流的方式，异步数据流运行占用少量的服务器线程资源（少量的CPU，少量的内存资源），从而构建一个高吞吐量的应用。 3. C
【从零开始的Springboot学习（一）】入门demo
真的好想再回到那时，可现在能做的只有补救。————个人博客：https://w7h1te.github.io/
04-01 576
打开官网https://spring.io/ Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”. 使用springboot搭建应用只需要打成jar包，然后执行 java -jar xxxx.jar命令 We take an opinionated view of the Spring platform and third
从零基础认识SpringBoot(一)入门
你不知道你不知道的事
08-15 1万+
SpringBoot D：SpringBoot为SpringMVC升级版。简化配置，很可能成为下一代的框架。 1.新建项目 Z：使用IntelliJ IDEA ， 其破解地址为：http://idea.lanyus.com/ 或者 https://jetlicense.nss.im/ M：怎么创建springBoot项目呢？ Z： 创建步骤复杂一点点 New...
如何将20.1.1.200这个网段固定分配给FTPserver
最新发布
07-09
要将网段20.1.1.200固定分配给FTP服务器，可以按照以下步骤进行操作： 1. 确保FTP服务器的网络接口与网络中的其他设备连接正常，并且已经获得了一个可用的IP地址。 2. 登录到网络路由器或交换机的管理界面。 3. ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值