【Lilishop商城】No2-2.确定软件架构搭建一（本篇包括MVC框架、持久框架、缓存、认证工具、安全框架等）


/lilishop-master/pom.xml
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.4.10version>
        <relativePath/>
    parent>
 
    <properties>
        <java.version>1.8java.version>
        <revision>4.2.5revision>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
    properties>

在 framework 项目路径下的 pom.xml 中指定使用的依赖包


/lilishop-master/framework/pom.xml
 
    <parent>
        <groupId>cn.liligroupId>
        <artifactId>lili-shop-parentartifactId>
        <version>${revision}version>
        <relativePath>../pom.xmlrelativePath>
    parent>
 
    <dependencies>
 
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-properties-migratorartifactId>
            <scope>runtimescope>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
            <exclusions>
                <exclusion>
                    <artifactId>log4j-to-slf4jartifactId>
                    <groupId>org.apache.logging.log4jgroupId>
                exclusion>
            exclusions>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-apiartifactId>
                    <groupId>org.slf4jgroupId>
                exclusion>
            exclusions>
        dependency>
    dependencies>

在业务包里的 pom.xml 文件中依赖 framework 模块，例如管理api、店铺api中


/lilishop-master/manager-api/pom.xml
 
    <parent>
        <groupId>cn.liligroupId>
        <artifactId>lili-shop-parentartifactId>
        <version>${revision}version>
        <relativePath>../pom.xmlrelativePath>
    parent>
 
    <dependencies>
        <dependency>
            <groupId>cn.liligroupId>
            <artifactId>frameworkartifactId>
            <version>${revision}version>
        dependency>
    dependencies>

然后在业务包里的代码路径中添加启动类，在resource的配置文件application.xml中设置配置信息，例如manager-api模块中


cn.lili.ManagerApiApplication
/**
 * 运营后台 API
 *
 * @author Chopper
 * @since 2020/11/16 10:03 下午
 */
@SpringBootApplication
public class ManagerApiApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(ManagerApiApplication.class, args);
    }
 
}


# /lilishop-master/manager-api/src/main/resources/application.yml
 
server:
  port: 8887
  servlet:
    context-path: /
  tomcat:
    uri-encoding: UTF-8
    threads:
      min-spare: 50
      max: 1000
 
spring:
  application:
    name: manager-api
  # 文件大小上传配置
  servlet:
    multipart:
      max-file-size: 20MB
      max-request-size: 20MB
  jackson:
    time-zone: GMT+8
    serialization:
      #关闭jackson 对json做解析
      fail-on-empty-beans: false

之后按照后端文档规范，使用@RestController等web注解就可以啦

A2.持久框架和分库分表

B1.持久框架

在 framework 项目路径下的 pom.xml 中指定使用的依赖包，并且在总项目路径中设置包的版本号


/lilishop-master/pom.xml
 
    <properties>
        <mybatis-plus-version>3.5.1mybatis-plus-version>
        <druid-version>1.2.8druid-version>
        <sharding-jdbc-version>4.0.0sharding-jdbc-version>
    properties>


/lilishop-master/framework/pom.xml
 
    <dependencies>
        
        <dependency>
            <groupId>com.baomidougroupId>
            <artifactId>mybatis-plus-boot-starterartifactId>
            <version>${mybatis-plus-version}version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-apiartifactId>
                    <groupId>org.slf4jgroupId>
                exclusion>
            exclusions>
        dependency>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>8.0.29version>
        dependency>
 
        
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>druidartifactId>
            <version>${druid-version}version>
        dependency>
 
        
        <dependency>
            <groupId>org.apache.shardingspheregroupId>
            <artifactId>sharding-jdbc-spring-boot-starterartifactId>
            <version>${sharding-jdbc-version}version>
            <exclusions>
                <exclusion>
                    <artifactId>groovyartifactId>
                    <groupId>org.codehaus.groovygroupId>
                exclusion>
                <exclusion>
                    <artifactId>commons-collections4artifactId>
                    <groupId>org.apache.commonsgroupId>
                exclusion>
                <exclusion>
                    <artifactId>antlr4-runtimeartifactId>
                    <groupId>org.antlrgroupId>
                exclusion>
                <exclusion>
                    <artifactId>slf4j-apiartifactId>
                    <groupId>org.slf4jgroupId>
                exclusion>
            exclusions>
        dependency>
        <dependency>
            <groupId>org.apache.shardingspheregroupId>
            <artifactId>sharding-jdbc-spring-namespaceartifactId>
            <version>${sharding-jdbc-version}version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-apiartifactId>
                    <groupId>org.slf4jgroupId>
                exclusion>
            exclusions>
        dependency>
 
    dependencies>

然后在业务包里的resource的配置文件application.xml中设置配置信息，一个是数据库链接，因为我们添加了 shardingsphere 的分库分表，所以先使用他的数据库链接配置。例如manager-api模块中

如果我们 mps 的mapper.xml 和接口包路径不同，就需要配置mybatis.mapperLocations


# /lilishop-master/manager-api/pom.xml
 
spring:
  shardingsphere:
    datasource:
      #  数据库名称，可自定义，可以为多个，以逗号隔开，每个在这里定义的库，都要在下面定义连接属性
      names: default-datasource
      default-datasource:
        type: com.alibaba.druid.pool.DruidDataSource
        driverClassName: com.mysql.cj.jdbc.Driver
        url: jdbc:mysql://127.0.0.1:3306/lilishop?useUnicode=true&characterEncoding=utf-8&useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=Asia/Shanghai
        username: username
        password: password
        maxActive: 20
        initialSize: 5
        maxWait: 60000
        minIdle: 5
        timeBetweenEvictionRunsMillis: 60000
        minEvictableIdleTimeMillis: 300000
        validationQuery: SELECT 1 FROM DUAL
        testWhileIdle: true
        testOnBorrow: false
        testOnReturn: false
        #是否缓存preparedStatement，也就是PSCache。在mysql下建议关闭。 PSCache对支持游标的数据库性能提升巨大，比如说oracle。
        poolPreparedStatements: false
        #要启用PSCache，-1为关闭 必须配置大于0，当大于0时，poolPreparedStatements自动触发修改为true  可以把这个数值配置大一些，比如说100
        maxOpenPreparedStatements: -1
        #配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
        filters: stat,wall,log4j2
        #通过connectProperties属性来打开mergeSql功能；慢SQL记录
        connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
        #合并多个DruidDataSource的监控数据
        useGlobalDataSourceStat: true
        loginUsername: druid
        loginPassword: druid
    #    sharding:
    #      default-data-source-name: default-datasource
    #      #需要拆分的表，可以设置多个  在 li_order 级别即可
    #      tables:
    #        #需要进行分表的逻辑表名
    #        li_order:
    #          #实际的表结点,下面代表的是li_order_为开头的所有表，如果能确定表的范围例如按月份分表，这里的写法是data2020.li_order_$->{2020..2021}_$->{01..12}  表示例如 li_order_2020_01 li_order_2020_03 li_order_2021_01
    #          actual-data-nodes: data2020.li_order_$->{2019..2021}_$->{01..12}
    #          table-strategy:
    #            # 分表策略，根据创建日期
    #            standard:
    #              sharding-column: create_time
    #              #分表策略
    #              precise-algorithm-class-name: cn.lili.mybatis.sharding.CreateTimeShardingTableAlgorithm
    #              #范围查询实现
    #              range-algorithm-class-name: cn.lili.mybatis.sharding.CreateTimeShardingTableAlgorithm
    props:
      #是否打印逻辑SQL语句和实际SQL语句，建议调试时打印，在生产环境关闭
      sql:
        show: false
 
 
 
# Mybatis-plus
mybatis-plus:
  # 如果mapper.xml文件和接口包路径不同，就需要mybatis.mapperLocations
  mapper-locations: classpath*:mapper/*.xml
  configuration:
    #缓存开启
    cache-enabled: true
    #日志
#    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

现在还需要配置 mps 其他设置，在 framework 模块里面

1.添加mapper接口的扫描@MapperScan；

2.创建数据库基础实体类，添加字段，例如创建人创建日期等大部分表都有得字段值；

3.创建MetaObjectHandler实现类，再插入或更新时自动设置字段指定默认值；作用就是自动处理基础字段，例如创建人创建日期等；

4.创建DefaultSqlInjector继承类，扩展BaseMapper，添加批量插入语句（IService自带的批量插入是单条插入性能较慢）；之后使用时别忘了重写BaseMapper，或者重写一个类继承BaseMapper，然后添加 insertBatchSomeColumn() 方法，之后直接通过mapper调用就行；

5.添加分页查件，创建MybatisPlusInterceptor是就加入这个插件，之后直接通过 iservice 和 mapper 调用使用；


//1.添加mapper接口的扫描@MapperScan；
 
@Configuration
@MapperScan({"cn.lili.modules.*.*.mapper", "cn.lili.modules.*.mapper"})
public class MybatisPlusConfig {
 
}


//2.创建数据库基础实体类，添加字段，例如创建人创建日期等大部分表都有得字段值；
//具体看：cn.lili.mybatis.BaseEntity 适用于业务表有创建人等信息
//具体看：cn.lili.mybatis.BaseIdEntity 适用于附加表没有创建人等信息
//注意：使用了 @TableId、@TableField ，这里没有使用逻辑删除@TableLogic


//3.创建MetaObjectHandler实现类，再插入或更新时自动设置字段指定默认值；作用就是自动处理基础字段，例如创建人创建日期等；
//具体看：cn.lili.mybatis.mybatisplus.MyMetaObjectHandler
//主要是重写 insertFill() updateFill() 方法，这个看注释就可以了，挺简单的


//4.创建DefaultSqlInjector继承类，扩展BaseMapper，添加批量插入语句（IService自带的批量插入是单条插入性能较慢）；之后使用时别忘了重写BaseMapper，或者重写一个类继承BaseMapper，然后添加 insertBatchSomeColumn() 方法，之后直接通过mapper调用就行；
//具体看cn.lili.mybatis.mybatisplus.external.SpiceSqlInjector，在里面将 InsertBatchSomeColumn 添加进去；
//之后创建一个接口SpiceBaseMapper，里面添加抽象方法，方法名按照首字母小写
//之后创建业务的mapper时，实现SpiceBaseMapper接口，然后调用方式执行就行啦
//例如
 
@Service
public class CustomWordsServiceImpl extends ServiceImpl implements CustomWordsService {
 
    @Override
    public long insertBatchCustomWords(List customWordsList) {
        //这里用的是自定义的~
        return this.baseMapper.insertBatchSomeColumn(customWordsList);
    }
}


//5.添加分页查件，创建MybatisPlusInterceptor是就加入这个插件，之后直接通过 iservice 和 mapper 调用使用；
 
@Configuration
@MapperScan({"cn.lili.modules.*.*.mapper", "cn.lili.modules.*.mapper"})
public class MybatisPlusConfig {
    /**
     * 向mps的过滤器中添加分页插件，自动识别数据库类型
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        PaginationInnerInterceptor pageInterceptor = new PaginationInnerInterceptor();
        // 设置请求的页面大于最大页后操作，true调回到首页，false继续请求。默认false
        pageInterceptor.setOverflow(true);
        // 单页分页条数限制，默认无限制
        pageInterceptor.setMaxLimit(500L);
        // 设置数据库类型
        pageInterceptor.setDbType(DbType.MYSQL);
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 添加分页插件
        interceptor.addInnerInterceptor(pageInterceptor);
        return interceptor;
    }
}

因为使用的是 mps ，那么简单的增删改查就可以使用 mps 提供的类 BaseMapper、IService 、ServiceImpl, T> ，进而使用他们提供的快捷调用方法，我们就不用在 mapper.xml 里面写对应的 sql 语句啦，只有很复杂的关联表操作的 sql 可能会用到。

B2.分库分表（待更新）

这个没有使用过，暂时也用不到，后面再添加~

A3.缓存

B1.缓存（Spring集成Redis和Spring-Cache）

在 framework 项目路径下的 pom.xml 中指定使用的依赖包，并且在总项目路径中设置包的版本号


/lilishop-master/pom.xml
 
    <properties>
        <redisson>3.15.6redisson>
    properties>


/lilishop-master/framework/pom.xml
 
    <dependencies>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
        dependency>
        
        
        <dependency>
            <groupId>org.redissongroupId>
            <artifactId>redissonartifactId>
            <version>${redisson}version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-apiartifactId>
                    <groupId>org.slf4jgroupId>
                exclusion>
            exclusions>
        dependency>
    dependencies>

然后在业务包里的resource的配置文件application.xml中设置配置信息，配置redis连接。例如manager-api模块中


# /lilishop-master/manager-api/pom.xml
 
spring:
  cache:
    type: redis
  # Redis
  redis:
    host: 127.0.0.1
    port: 6379
#    password: lilishop
    lettuce:
      pool:
        # 连接池最大连接数（使用负值表示没有限制） 默认 8
        max-active: 200
        # 连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
        max-wait: 20
        # 连接池中的最大空闲连接 默认 8
        max-idle: 10
        # 连接池中的最小空闲连接 默认 8
        min-idle: 8

操作 redis 有两种方式，一个是springcache一个是spring集成redis，各有各的优势

redisTemplate ，是Spring集成Redis，我们自己调用实现缓存操作
CacheManger，是Spring-Cache，通过注解方式实现缓存

为什么使用 springcache?可以看这篇文章：SpringCache整合Redis实现项目缓存解决方案_IT美男子的博客-CSDN博客_springcache整合redis

这两种，我们都使用，所以都进行配置，都在 framework 模块里面配置：

1.首先定义一个自定义的序列化，这样方便使用工具查看redis存储，避免乱码；

2.配置springcache的 CacheManager，之后直接使用 @Cacheable 等注解就行；

3.配置spring集成redis的RedisTemplate，为了方便使用redis，我们可以添加操作工具Cache类；之后直接使用 Cache 调用方法就行；同时还可以创建一个缓存前缀类专门存放缓存的key前缀；


//1.首先定义一个自定义的序列化，这样方便使用工具查看redis存储，避免乱码；
//详见：cn.lili.cache.config.redis.FastJsonRedisSerializer


//2.配置springcache的 CacheManager，
//详见：cn.lili.cache.config.redis.RedisConfig
 
@Slf4j
@Configuration
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
public class RedisConfig extends CachingConfigurerSupport {
 
 
    private static final String REDIS_PREFIX = "redis://";
 
    @Value("${lili.cache.timeout:7200}")
    private Integer timeout;
 
    /**
     * 当有多个管理器的时候，必须使用@Primary该注解在一个管理器上注释：表示该管理器为默认的管理器
     *
     * @param connectionFactory 链接工厂
     * @return 缓存
     */
    @Bean
    @Primary
    public CacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        //初始化一个RedisCacheWriter
        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory);
        //序列化方式2
        FastJsonRedisSerializer