java开源项目jeecgboot的超详细解析

2022-11-13 18:11:16 开源 项目 解析

一.搭建

1.前端

npm install
npm run serve

2.后端

老生常谈的配置,修改MysqlRedis即可。

二.业务功能介绍

功能上jeecgboot主要提供了系列的代码生成器、模板页面、报表页面。

1.报表功能

主要提供报表的相关操作。提供了积木报表插件,可以自定义数据报表、图形报表。并将报表挂载到菜单上。

2.在线开发

也就是代码生成器,可以可视化的在页面上新建数据库表,并通过数据库表生成前后台代码。减少业务代码开发的时间。

3.系统管理

用户管理、角色管理、机构管理、消息管理等基础模块。

4.系统监控

主要负责各种日志、监控的统一处理。

5.页面组件样式

常见案例、详情页、结果页、异常页、列表页、表单页主要提供了样式页面与控件页面示例。在开发过程中如果需要模板直接复制代码即可。详情请

三.后台架构介绍

1.概括

其中报表和代码生成器没有提供源码,如果有兴趣可以自行查看jar包源码。

2.架构核心包jeecg-boot-base

jeecg-boot-base包括了下文的几个部分。

1.接口包jeecg-boot-base-api

1.对外接口jeecg-system-cloud-api

使用feign+hystrix实现了服务间调用加熔断,单机环境并没有使用。

2.服务内接口jeecg-system-local-api

该包提供了下文使用的常用方法接口。仅提供了接口并无其他配置。

2.核心配置包jeecg-boot-base-core

1.通用类common 1.api

其中为通用接口与通用返回对象。

1.Result

其中Result为所有类的返回实体,这样能够通过code编码和message获取是否成功和成功/失败的信息。此类是常用的架构设计

2.aspect

项目的自定义注解,使用了aop的切面方式实现,这里就不详细说了,比较简单都可以看懂。

3.constant

存放着枚举类与常量池,这里不多说了。

4.es

为操作es的通用类,主要是配置es连接和查询时动态拼接and/or的方法。

5.exception

exception为自定义的异常类。

1.JeecgBootExceptionHandler

这里详细说一下JeecgBootExceptionHandler,该类也是常见的架构设计之一,核心为@RestControllerAdvice、@ExceptionHandler。当业务代码中没有对异常拦截时,该类会自动拦截异常,并数据log日志。所以某些日志在该类配置后,就不需要在每个接口中都捕获这个异常了。

6.handler

为下文规范提供了接口类。没有其他特别说明。

7.system类

这里主要说controller、entity、service等业务代码的父类

1.JeecgController<T, S extends IService>

所以controller的父类,提供了导入导出的功能。还可以在里面扩展分页、排序、常用调用方法等,这样就可以避免相同的代码多次添加。这也是架构设计中常用的技巧。

2.JeecgEntity

将通用字段如id、创建人、修改人、创建时间、修改时间等字段统一封装在一个实体中,使用其他实体继承。这也是架构设计中常用的技巧。

3.service

主要提供mybatis-plus提供的curd方法。

8.utli

提供了一大波的工具类,如果在工作中需要,直接复制使用。

2.通用配置类config

1.mybatis

1.MybatisInterceptor

MybatisInterceptor这里主要说MybatisInterceptor,该类负责在mybatis执行语句前,拦截并获取参数,将创建人、创建时间等字符动态插入。这里上部分核心代码。

MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
		String sqlId = mappedStatement.getId();
		log.debug("------sqlId------" + sqlId);
		//获取sql类型是插入还是修改
		SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
		//获取插入参数
		Object parameter = invocation.getArgs()[1];
		if (parameter == null) {
			return invocation.proceed();
		}
		if (SqlCommandType.INSERT == sqlCommandType) {
			LoginUser sysUser = this.getLoginUser();
			//通过反射获取入参的类
			Field[] fields = oConvertUtils.getAllFields(parameter);
			for (Field field : fields) {
				log.debug("------field.name------" + field.getName());
				try {
				    //将创建人信息动态加入
					if ("createBy".equals(field.getName())) {
						field.setAccessible(true);
						Object local_createBy = field.get(parameter);
						field.setAccessible(false);
						if (local_createBy == null || local_createBy.equals("")) {
							if (sysUser != null) {
								// 登录人账号
								field.setAccessible(true);
								field.set(parameter, sysUser.getUsername());
								field.setAccessible(false);
							}
						}
					}
			}		

2.MybatisPlusSaasConfig

该类主要负责多租户,什么是多租户呢?

多租户:就是多个公司/客户公用一套系统/数据库,这就需要保证数据的权限。

该场景比较少不详细说明。

2.oss

主要从application-dev.yml获取到上传的路径与配置。

3.shiro

安全框架主要有两个目标:认证与鉴权。

认证:判断用户名密码是否正确。

鉴权:判断用户是否有权限访问该接口。

这里本文着重讲解,如果遇到shiro相关应用,可以项目直接移植使用。

1.CustomShiroFilterFactoryBean

该类主要负责解决资源中文路径问题。这里有个通用的解决方式。

新建类集成ShiroFilterFactoryBean方法,并重写核心方法createInstance(),并在注入时,注入新建的类CustomShiroFilterFactoryBean,这样就达到的以往重新源码的功能。因为spring提供的功能都是用该思想,所以修改源码的地方就原来越少了,都可以使用该方式实现。

2.JwtFilter

同上文,复写BasicHttpAuthenticationFilter的验证登录用户的方法,在执行登录接口后判断用户是否正确。

3.ResourceCheckFilter

负责鉴权使用,判断当前用户是否有权限访问。

    //表示是否允许访问 ,如果允许访问返回true,否则false;
    @Override
    protected boolean isAccessAllowed(ServletRequest servletRequest, ServletResponse servletResponse, Object o) throws Exception {
        Subject subject = getSubject(servletRequest, servletResponse);
        //获取当前url
        String url = getPathWithinApplication(servletRequest);
        log.info("当前用户正在访问的 url => " + url);
        return subject.isPermitted(url);
    }

    //onAccessDenied:表示当访问拒绝时是否已经处理了; 如果返回 true 表示需要继续处理; 如果返回 false
    @Override
    protected boolean onAccessDenied(ServletRequest servletRequest, ServletResponse servletResponse) throws Exception {
        httpservletRequest request = (HttpServletRequest) servletRequest;
        HttpServletResponse response = (HttpServletResponse) servletResponse;
        response.sendRedirect(request.getContextPath() + this.errorUrl);
        // 返回 false 表示已经处理,例如页面跳转啥的,表示不在走以下的拦截器了(如果还有配置的话)
        return false;
    }

4.ShiroRealm

主要负责获取用户所有的菜单权限,并提供token的一系列方法。

    //获取所有菜单权限集合
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {  
    }

    //验证用户输入的账号和密码是否正确
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken auth) throws AuthenticationException {
    }

    //校验token的有效性
    public LoginUser checkUserTokenIsEffect(String token) throws AuthenticationException {
    }

    //刷新token有效时间
    public boolean JwtTokenRefresh(String token, String userName, String passWord) {
    }

    //清除当前用户的权限认证缓存
    @Override
    public void clearCache(PrincipalCollection principals) {
        super.clearCache(principals);
    }

5.ShiroConfig

此为shiro的核心配置类,大多数写法都是固定写法。

public class ShiroConfig {

    @Value("${jeecg.shiro.excludeUrls}")
    private String excludeUrls;
    @Resource
    LettuceConnectionFactory lettuceConnectionFactory;
    @Autowired
    private Environment env;


    
    @Bean("shiroFilter")
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
        CustomShiroFilterFactoryBean shiroFilterFactoryBean = new CustomShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        // 拦截器
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<String, String>();
        if(oConvertUtils.isNotEmpty(excludeUrls)){
            String[] permissionUrl = excludeUrls.split(",");
            for(String url : permissionUrl){
                filterChainDefinitionMap.put(url,"anon");
            }
        }
        // 配置不会被拦截的链接 顺序判断 也就是不同通过token访问的地址
        filterChainDefinitionMap.put("/sys/cas/client/validateLogin", "anon"); /
  
        // 添加自己的过滤器并且取名为jwt
        Map<String, Filter> filterMap = new HashMap<String, Filter>(1);
        //如果cloudServer为空 则说明是单体 需要加载跨域配置【微服务跨域切换】
        Object cloudServer = env.getProperty(CommonConstant.CLOUD_SERVER_KEY);
        //前文定义的过滤器
        filterMap.put("jwt", new JwtFilter(cloudServer==null));
        shiroFilterFactoryBean.setFilters(filterMap);
        // <!-- 过滤链定义,从上向下顺序执行,一般将
                channel.basicNack(deliveryTag, false, true);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}

public interface MQListener<T> {

    default void handler(T map, Channel channel) {
    }
}

2.RabbitMqClient

主要在队列初始化时实现队列的初始化,而是否初始化根据使用时的@RabbitListener、@RabbitComponent判断。

	public interface MqListener<T> {
	    default void handler(T map, Channel channel) {
	    }
	}

    @Bean
    public void initQueue() {
        //获取带RabbitComponent注解的类
        Map<String, Object> beansWithRqbbitComponentMap = this.applicationContext.getBeansWithAnnotation(RabbitComponent.class);
        Class<? extends Object> clazz = null;
        //循环map
        for (Map.Entry<String, Object> entry : beansWithRqbbitComponentMap.entrySet()) {
            log.info("初始化队列............");
            //获取到实例对象的class信息
            clazz = entry.getValue().getClass();
            Method[] methods = clazz.getMethods();
            //判断是否有RabbitListener注解
            RabbitListener rabbitListener = clazz.getAnnotation(RabbitListener.class);
            //类上有注解 就创建队列
            if (ObjectUtil.isNotEmpty(rabbitListener)) {
                createQueue(rabbitListener);
            }
            //方法上有注解 就创建队列
            for (Method method : methods) {
                RabbitListener methodRabbitListener = method.getAnnotation(RabbitListener.class);
                if (ObjectUtil.isNotEmpty(methodRabbitListener)) {
                    createQueue(methodRabbitListener);
                }
            }
        }
    }

    
    private void createQueue(RabbitListener rabbitListener) {
        String[] queues = rabbitListener.queues();
        //创建交换机
        DirectExchange directExchange = createExchange(DelayExchangeBuilder.DELAY_EXCHANGE);
        rabbitAdmin.declareExchange(directExchange);
        //创建队列
        if (ObjectUtil.isNotEmpty(queues)) {
            for (String queueName : queues) {
                Properties result = rabbitAdmin.getQueueProperties(queueName);
                if (ObjectUtil.isEmpty(result)) {
                    Queue queue = new Queue(queueName);
                    addQueue(queue);
                    Binding binding = BindingBuilder.bind(queue).to(directExchange).with(queueName);
                    rabbitAdmin.declareBinding(binding);
                    log.info("创建队列:" + queueName);
                }else{
                    log.info("已有队列:" + queueName);
                }
            }
        }
    }

3.RabbitMqConfig

消息队列的常用配置方式。这里不多描述。

4.event

这个包主要是为使用mq发送消息使用,多类别的消息会实现JeecgBusEventHandler类,而BaseApplicationEvent通过消息类型传入的不同的参数选择合适的业务类发送消息。

5.DelayExchangeBuilder

为延时队列的交换机声明与绑定。

2.jeecg-boot-starter-lock

1.如何使用分布式锁

使用时有两种方式,一种是使用注解方式,一种是使用redisson提供的API。

@Scheduled(cron = "0/5 * * * * ?")
    @JLock(lockKey = CloudConstant.REDISSON_DEMO_LOCK_KEY1)
    public void execute() throws InterruptedException {
        log.info("执行execute任务开始,休眠三秒");
        Thread.sleep(3000);
        System.out.println("=======================业务逻辑1=============================");
        Map map = new BaseMap();
        map.put("orderId", "BJ0001");
        RabbitMQClient.sendMessage(CloudConstant.MQ_JEECG_PLACE_ORDER, map);
        //延迟10秒发送
        map.put("orderId", "NJ0002");
        rabbitMqClient.sendMessage(CloudConstant.MQ_JEECG_PLACE_ORDER, map, 10000);
        log.info("execute任务结束,休眠三秒");
    }

    public DemoLockTest() {
    }

    
    //@Scheduled(cron = "0/5 * * * * ?")
    public void execute2() throws InterruptedException {
        if (redissonLock.tryLock(CloudConstant.REDISSON_DEMO_LOCK_KEY2, -1, 6000)) {
            log.info("执行任务execute2开始,休眠十秒");
            Thread.sleep(10000);
            System.out.println("=======================业务逻辑2=============================");
            log.info("定时execute2结束,休眠十秒");

            redissonLock.unlock(CloudConstant.REDISSON_DEMO_LOCK_KEY2);
        } else {
            log.info("execute2获取失败");
        }
    }

2.RepeatSubmitAspect

通过公平锁判断是否是多次点击按钮。

    @Around("pointCut(jRepeat)")
    public Object repeatSubmit(ProceedingJoinPoint joinPoint,JRepeat jRepeat) throws Throwable {
        String[] parameterNames = new LocalVariableTableParameterNameDiscoverer().getParameterNames(((MethodSignature) joinPoint.getSignature()).getMethod());
        if (Objects.nonNull(jRepeat)) {
            // 获取参数
            Object[] args = joinPoint.getArgs();
            // 进行一些参数的处理,比如获取订单号,操作人id等
            StringBuffer lockKeyBuffer = new StringBuffer();
            String key =getValueBySpEL(jRepeat.lockKey(), parameterNames, args,"RepeatSubmit").get(0);
            // 公平加锁,lockTime后锁自动释放
            boolean isLocked = false;
            try {
                isLocked = redissonLockClient.fairLock(key, TimeUnit.SECONDS, jRepeat.lockTime());
                // 如果成功获取到锁就继续执行
                if (isLocked) {
                    // 执行进程
                    return joinPoint.proceed();
                } else {
                    // 未获取到锁
                    throw new Exception("请勿重复提交");
                }
            } finally {
                // 如果锁还存在,在方法执行完成后,释放锁
                if (isLocked) {
                    redissonLockClient.unlock(key);
                }
            }
        }
        return joinPoint.proceed();
    }

3.DistributedLockHandler

该类主要是jLock的切面类,通过jLock注解参数,判断需要加锁的类型,同时加锁的方法也不相同。

    //jLock切面,进行加锁
    @SneakyThrows
    @Around("@annotation(jLock)")
    public Object around(ProceedingJoinPoint joinPoint, JLock jLock) {
        Object obj = null;
        log.info("进入RedisLock环绕通知...");
        RLock rLock = getLock(joinPoint, jLock);
        boolean res = false;
        //获取超时时间
        long expireSeconds = jLock.expireSeconds();
        //等待多久,n秒内获取不到锁,则直接返回
        long waitTime = jLock.waitTime();
        //执行aop
        if (rLock != null) {
            try {
                if (waitTime == -1) {
                    res = true;
                    //一直等待加锁
                    rLock.lock(expireSeconds, TimeUnit.MILLISECONDS);
                } else {
                    res = rLock.tryLock(waitTime, expireSeconds, TimeUnit.MILLISECONDS);
                }
                if (res) {
                    obj = joinPoint.proceed();
                } else {
                    log.error("获取锁异常");
                }
            } finally {
                if (res) {
                    rLock.unlock();
                }
            }
        }
        log.info("结束RedisLock环绕通知...");
        return obj;
    }

    //通过参数判断加锁类型
    @SneakyThrows
    private RLock getLock(ProceedingJoinPoint joinPoint, JLock jLock) {
        //获取key
        String[] keys = jLock.lockKey();
        if (keys.length == 0) {
            throw new RuntimeException("keys不能为空");
        }
        //获取参数
        String[] parameterNames = new LocalVariableTableParameterNameDiscoverer().getParameterNames(((MethodSignature) joinPoint.getSignature()).getMethod());
        Object[] args = joinPoint.getArgs();
        LockModel lockModel = jLock.lockModel();
        if (!lockModel.equals(LockModel.MULTIPLE) && !lockModel.equals(LockModel.REDLOCK) && keys.length > 1) {
            throw new RuntimeException("参数有多个,锁模式为->" + lockModel.name() + ".无法锁定");
        }
        RLock rLock = null;
        String keyConstant = jLock.keyConstant();
        //判断锁类型
        if (lockModel.equals(LockModel.AUTO)) {
            if (keys.length > 1) {
                lockModel = LockModel.REDLOCK;
            } else {
                lockModel = LockModel.REENTRANT;
            }
        }
        //根据不同的锁类型执行不同的加锁方式
        switch (lockModel) {
            case FAIR:
                rLock = redissonClient.getFairLock(getValueBySpEL(keys[0], parameterNames, args, keyConstant).get(0));
                break;
            case REDLOCK:
                List<RLock> rLocks = new ArrayList<>();
                for (String key : keys) {
                    List<String> valueBySpEL = getValueBySpEL(key, parameterNames, args, keyConstant);
                    for (String s : valueBySpEL) {
                        rLocks.add(redissonClient.getLock(s));
                    }
                }
                RLock[] locks = new RLock[rLocks.size()];
                int index = 0;
                for (RLock r : rLocks) {
                    locks[index++] = r;
                }
                rLock = new RedissonRedLock(locks);
                break;
            case MULTIPLE:
                rLocks = new ArrayList<>();
                for (String key : keys) {
                    List<String> valueBySpEL = getValueBySpEL(key, parameterNames, args, keyConstant);
                    for (String s : valueBySpEL) {
                        rLocks.add(redissonClient.getLock(s));
                    }
                }
                locks = new RLock[rLocks.size()];
                index = 0;
                for (RLock r : rLocks) {
                    locks[index++] = r;
                }
                rLock = new RedissonMultiLock(locks);
                break;
            case REENTRANT:
                List<String> valueBySpEL = getValueBySpEL(keys[0], parameterNames, args, keyConstant);
                //如果spel表达式是数组或者LIST 则使用红锁
                if (valueBySpEL.size() == 1) {
                    rLock = redissonClient.getLock(valueBySpEL.get(0));
                } else {
                    locks = new RLock[valueBySpEL.size()];
                    index = 0;
                    for (String s : valueBySpEL) {
                        locks[index++] = redissonClient.getLock(s);
                    }
                    rLock = new RedissonRedLock(locks);
                }
                break;
            case READ:
                rLock = redissonClient.getReadWriteLock(getValueBySpEL(keys[0], parameterNames, args, keyConstant).get(0)).readLock();
                break;
            case WRITE:
                rLock = redissonClient.getReadWriteLock(getValueBySpEL(keys[0], parameterNames, args, keyConstant).get(0)).writeLock();
                break;
        }
        return rLock;
    }

4.RedissonLockClient

redisson客户端,提供了一大波方法,请自行查看。

public class RedissonLockClient {

    @Autowired
    private RedissonClient redissonClient;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    
    public RLock getLock(String lockKey) {
        return redissonClient.getLock(lockKey);
    }

    
    public boolean tryLock(String lockName, long expireSeconds) {
        return tryLock(lockName, 0, expireSeconds);
    }
    .
    .
    .

5.core包

主要通过application.yml配置文件获取redis连接类型,通过根据该参数动态的选择策略类,连接redis。

public class RedissonManager {
    public Redisson getRedisson() {
        return redisson;
    }

    //Redisson连接方式配置工厂
    static class RedissonConfigFactory {

        private RedissonConfigFactory() {
        }

        private static volatile RedissonConfigFactory factory = null;

        public static RedissonConfigFactory getInstance() {
            if (factory == null) {
                synchronized (Object.class) {
                    if (factory == null) {
                        factory = new RedissonConfigFactory();
                    }
                }
            }
            return factory;
        }


        //根据连接类型創建连接方式的配置
        Config createConfig(RedissonProperties redissonProperties) {
            Preconditions.checkNotNull(redissonProperties);
            Preconditions.checkNotNull(redissonProperties.getAddress(), "redis地址未配置");
            RedisConnectionType connectionType = redissonProperties.getType();
            // 声明连接方式
            RedissonConfigStrategy redissonConfigStrategy;
            if (connectionType.equals(RedisConnectionType.SENTINEL)) {
                redissonConfigStrategy = new SentinelRedissonConfigStrategyImpl();
            } else if (connectionType.equals(RedisConnectionType.CLUSTER)) {
                redissonConfigStrategy = new ClusterRedissonConfigStrategyImpl();
            } else if (connectionType.equals(RedisConnectionType.MASTERSLAVE)) {
                redissonConfigStrategy = new MasterslaveRedissonConfigStrategyImpl();
            } else {
                redissonConfigStrategy = new StandaloneRedissonConfigStrategyImpl();
            }
            Preconditions.checkNotNull(redissonConfigStrategy, "连接方式创建异常");

            return redissonConfigStrategy.createRedissonConfig(redissonProperties);
        }
    }
}

//策略实现,此类是指定redis的连接方式是哨兵。
public class SentinelRedissonConfigStrategyImpl implements RedissonConfigStrategy {

	@Override
	public Config createRedissonConfig(RedissonProperties redissonProperties) {
		Config config = new Config();
		try {
			String address = redissonProperties.getAddress();
			String password = redissonProperties.getPassword();
			int database = redissonProperties.getDatabase();
			String[] addrTokens = address.split(",");
			String sentinelAliasName = addrTokens[0];
			// 设置redis配置文件sentinel.conf配置的sentinel别名
			config.useSentinelServers().setMasterName(sentinelAliasName);
			config.useSentinelServers().setDatabase(database);
			if (StringUtils.isNotBlank(password)) {
				config.useSentinelServers().setPassword(password);
			}
			// 设置哨兵节点的服务IP和端口
			for (int i = 1; i < addrTokens.length; i++) {
				config.useSentinelServers().addSentinelAddress(GlobalConstant.REDIS_CONNECTION_PREFIX+ addrTokens[i]);
			}
			log.info("初始化哨兵方式Config,redisAddress:" + address);
		} catch (Exception e) {
			log.error("哨兵Redisson初始化错误", e);
			e.printStackTrace();
		}
		return config;
	}
}


6.jeecg-cloud-module

这里详细的说一下jeecg-cloud-gateway,因为其他的都是开源项目没下载即用。

jeecg-cloud-system-start为封装start的使用方法,上文已经介绍了。

1.jeecg-cloud-gateway

1.GatewayRoutersConfiguration

当固定的几个路由,有特殊化的执行方法。

2.RateLimiterConfiguration

主要配置限流,与application.yml一起使用,下文配置含义是,发送过来的请求只能容纳redis-rate-limiter.burstCapacity的配置(3次)多余的会全部丢弃(限流),每秒消费redis-rate-limiter.replenishRate(1次)。

3.FallbackController

熔断的执行方法。

4.GlobalAccessTokenFilter

全局拦截器,在调用其他服务时,将用户信息放在请求头中。

5.SentinelFilterContextConfig

使Sentinel链路流控模式生效,固定写法。

6.HystrixFallbackHandler、SentinelBlockRequestHandler

在降级/限流时,将异常信息转换成JSON返回给前台。

7.LoderRouderHandler

动态刷新路由。

8.MySwaggerResourceProvider、SwaggerResourceController

swagger地址统一管理起来

9.DynamicRouteLoader、DynamicRouteService

DynamicRouteLoader:通过application.yml判断从Nacos/redis中获取路由信息,并实现动态的加载。
DynamicRouteService:为底层处理路由的API。

四.总体感想

文章到这里差不多就接近尾声了,大多数功能附带着代码都讲述了一遍。在功能上来说,jeecg提供了很多常用功能,如rabbitMq封装、积木报表、代码生成器等。这些在日常工作中有很大的概率碰上,如果有以上需求,可以来框架中直接复制粘贴即可。

但是在格式规范上,如出入参的规范,代码的写法,代码的格式化等方面,并不是特别统一,且没有严格规范。总体来说非常适合做私活与毕业设计,同时也是最早一批开源的前后端项目脚手架,爆赞。

到此这篇关于java开源项目jeecgboot的文章就介绍到这了,更多相关java开源项目jeecgboot内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持!

相关文章