java项目中常用配置与使用说明

spring项目： 1、pom.xml文件（1）xml文件被编译

代码中的***.xml那就是让spring项目中的的xml也被编译。

 
 

      
        src/main/java
        
        
          
          ***.xml
        
        false
      


      
        src/main/resources
        
        
          
          ***.xml
        
        false

2、application.yml配置（1）端口配置

server:
  port: 8080

（2）mysql配置

spring:
  datasource:
    username: 
    password: 
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost/byd

reids项目： 1、redis.conf （1）连接配置

# 允许访问的地址，默认是127.0.0.1，会导致只能在本地访问。修改为0.0.0.0则可以在任意IP访问，生产环境不要设置为0.0.0.0  第75行
bind 0.0.0.0
# 守护进程，修改为yes后即可后台运行   第257行
daemonize yes
# 监听的端口
port 6379
# 工作目录，默认是当前目录，也就是运行redis-server时的命令，日志、持久化等文件会保存在这个目录
dir .
# 数据库数量，设置为1，代表只使用1个库，默认有16个库，编号0~15
databases 1
# 设置redis能够使用的最大内存
maxmemory 512mb
# 日志文件，默认为空，不记录日志，可以指定日志文件名
logfile "redis.log"

（2）RDB持久化配置

# 是否压缩 ,建议不开启，压缩也会消耗cpu，磁盘的话不值钱
# 360 行 
rdbcompression yes
# RDB文件名称
dbfilename dump.rdb  
# 文件保存的路径目录
dir ./

（3）AOF持久化配置

# 是否开启AOF功能，默认是no
# 1251 行 
appendonly yes
# AOF文件的名称
appendfilename "appendonly.aof"
# 表示每执行一次写命令，立即记录到AOF文件
appendfsync always 
# 写命令执行完先放入AOF缓冲区，然后表示每隔1秒将缓冲区数据写到AOF文件，是默认方案
appendfsync everysec 
# 写命令执行完先放入AOF缓冲区，由操作系统决定何时将缓冲区内容写回磁盘
appendfsync no
# AOF文件比上次文件 增长超过多少百分比则触发重写
auto-aof-rewrite-percentage 100
# AOF文件体积最小多大以上才触发重写 
auto-aof-rewrite-min-size 64mb

2、application.yml配置（1）java连接redis

该配置的作用是使java和redis可以连接，主要配置了redis的地址和端口。

spring:
  # 配置连接redis的主机地址、端口
  redis:
    host: 127.0.0.1
    port: 6379

（2）java连接redis 哨兵

spring:
  redis:
    sentinel:
      master: mymaster
      nodes:
        - 192.168.60.129:27001
        - 192.168.60.129:27002
        - 192.168.60.129:27003

3、配置类（1）序列化配置

该配置类的作用是让redis中键和值的序列化保持不一致。因为redis中默认键和值的序列化方式是一致的，要么是字符串序列化，要么是对象序列化。但是实际开发中键的数据类型往往是字符串，而值的数据类型往往是对象，因此要在这里配置，使键和值的序列化方式分离避免出现序列化失误的情况。

package com.woniu.config;
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.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;


@Configuration
public class RedisConfig {
    
    @Bean
    public RedisTemplate  redisTemplate(RedisConnectionFactory redisConnectionFactory){

        RedisTemplate redisTemplate = new RedisTemplate();

        redisTemplate.setConnectionFactory(redisConnectionFactory);


        //设置key的序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringRedisSerializer);

        //设置value的序列化
        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();

        // Jackson2JsonRedisSerializer 这个完成序列化操作
        // 不能把 序列化字符串 转成 java 对象
        redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);

        // hash类型key的序列化方式
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        // hash类型value的序列化方式
        redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);

        return redisTemplate;
    }  
}

（2）读写分离配置

该类是写在springboot启动类中，配置redis的读写分离，其中包括了四种读写策：（1）MASTER：从主节点读取。（2）MASTER_PREFERRED：优先从master节点读取，master不可用才读取replica。（3）REPLICA：从slave（replica）节点读取。（4）REPLICA _PREFERRED：优先从slave（replica）节点读取，所有的slave都不可用才读取master。

@Bean
public LettuceClientConfigurationBuilderCustomizer clientConfigurationBuilderCustomizer(){
    return clientConfigurationBuilder -> clientConfigurationBuilder.readFrom(ReadFrom.REPLICA_PREFERRED);
}

3、访问分片集群（1）读写分离配置

@Bean
public LettuceClientConfigurationBuilderCustomizer clientConfigurationBuilderCustomizer(){
        return clientConfigurationBuilder -> clientConfigurationBuilder.readFrom(ReadFrom.REPLICA_PREFERRED);
}

（2）application.yml配置

spring:
  redis:
    cluster:
      nodes:
        - 192.168.60.129:7001
        - 192.168.60.129:7002
        - 192.168.60.129:7003
        - 192.168.60.129:8001
        - 192.168.60.129:8002
        - 192.168.60.129:8003

Shiro项目： 1、配置类

package com.woniu.config;
import com.woniu.realm.MyRealm;
import org.apache.shiro.authc.credential.CredentialsMatcher;
import org.apache.shiro.authc.credential.HashedCredentialsMatcher;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;


@Configuration
public class ShiroConfig {

    //进行加密的设置
    @Bean
    public CredentialsMatcher credentialsMatcher(){
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        // 指定加密算法
        matcher.setHashAlgorithmName("md5");
        // 迭代次数
        matcher.setHashIterations(3);
        return matcher;
    }

    // 新建MyRealm对象的方法
    @Bean
    public MyRealm createMyRealm(CredentialsMatcher credentialsMatcher){

        MyRealm myRealm = new MyRealm();
        myRealm.setCredentialsMatcher(credentialsMatcher);

        return myRealm;
    }

    // 新建SecurityManager对象
    @Bean
    public SecurityManager createSecurityManager(MyRealm myRealm){

        DefaultWebSecurityManager dwsm = new DefaultWebSecurityManager();
        dwsm.setRealm(myRealm);

        return dwsm;
    }

    // 往容器中丢入过滤器
    @Bean
    public ShiroFilterFactoryBean createShiroFilterFactoryBean(SecurityManager securityManager){

        // 新建ShiroFilterFactoryBean对象
        ShiroFilterFactoryBean sffb = new ShiroFilterFactoryBean();
        sffb.setSecurityManager(securityManager);

        HashMap map = new HashMap<>();

        // 设置登录页面
        sffb.setLoginUrl("/login.html");

        // 开放资源      
        // 1、开发静态资源
        map.put("/css
    //5.1 开启Aop自动代理
    @Bean
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator(){
        DefaultAdvisorAutoProxyCreator proxy =
                new DefaultAdvisorAutoProxyCreator();
        // 设置true表示使用子类代理
        proxy.setProxyTargetClass(true);
        return proxy;
    }

    //5.2 匹配所有加了权限注解的方法，让权限校验注解生效。注入SecurityManager
    @Bean
    public AuthorizationAttributeSourceAdvisor advisor(SecurityManager securityManager){
        AuthorizationAttributeSourceAdvisor advisor =
                new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(securityManager);
        return advisor;
    }


}

2、自定义realm

package com.woniu.realm;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.woniu.bean.Permission;
import com.woniu.bean.RolePermission;
import com.woniu.bean.User;
import com.woniu.bean.UserRole;
import com.woniu.mapper.UserMapper;
import com.woniu.service.IPermissionService;
import com.woniu.service.IRolePermissionService;
import com.woniu.service.IUserRoleService;
import com.woniu.service.IUserService;
import lombok.extern.slf4j.Slf4j;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.AuthenticationInfo;
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.SimpleAuthenticationInfo;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;

import java.util.List;


@Slf4j
public class MyRealm extends AuthorizingRealm {

    @Lazy
    @Autowired
    IUserService userService;
    
    @Lazy
    @Autowired
    IUserRoleService userRoleService;

    @Lazy
    @Autowired
    IPermissionService permissionService;
    
    @Lazy
    @Autowired
    IRolePermissionService rolePermissionService;
    
    @Autowired
    UserMapper userMapper;

    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {

        // 拿到User,并拿到uid
        User user = (User) principalCollection.getPrimaryPrincipal();
        Integer uid = user.getUid();

        // 拿到rids
        QueryWrapper qw = new QueryWrapper<>();
        qw.eq("uid",uid);
        qw.select("rid");
        List

java项目中常用配置与使用说明

Java相关栏目本月热门文章