xplly'Blog

标签

工具

spring

字数

3152 字

阅读时间

18 分钟

AOPUtil

java


import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.reflect.MethodSignature;

import java.lang.reflect.Method;

/**
 * AOP工具类
 *
 * @author Brack.zhu
 * @date 2021/1/20
 */
public class AopUtil {

    private AopUtil() {

    }

    /**
     * 获取AOP切入点的执行方法
     *
     * @param pjp AOP切入点
     * @return Method对象
     * @throws NoSuchMethodException
     */
    public static Method getMethod(ProceedingJoinPoint pjp) throws NoSuchMethodException {
        MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
        Method method = methodSignature.getMethod();
        return pjp.getTarget().getClass().getMethod(method.getName(), method.getParameterTypes());
    }


}

ApplicationUtil

java


/**
 * 应用服务工具类
 * @author Brack.zhu
 * @date 2020/9/21
 */
public class ApplicationUtil {

    private ApplicationUtil() {

    }

    /**
     * 获取当前服务实例ID<br/>
     *  实例id主要用于微服务中在单个服务中区分各实例。<br/>
     *   借鉴了Eureka 的Instance ID格式,实例id组成:ip:服务端口
     * @return
     */
    public static String getInstanceId(){
        String localIp=SpringContextUtil.getEnvProperty("spring.cloud.client.ip-address");
        String port=SpringContextUtil.getEnvProperty("server.port");
        return  localIp+":"+port;
    }

}

BeanRegistryUtil

java


import com.commnetsoft.commons.utils.StringUtils;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.BeanDefinitionReaderUtils;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.util.ClassUtils;

import java.util.Map;
import java.util.Objects;

/**
 * Bean 注入注册工具类<br/>
 * {@link BeanDefinitionReaderUtils}
 *
 * @author Brack.zhu
 * @date 2020/7/13
 */
public class BeanRegistryUtil extends BeanDefinitionReaderUtils {

    private BeanRegistryUtil() {
    }

    /**
     * 注册bean到Spring容器中<br/>
     *
     * @param registry  注册器
     * @param beanClass 需要注册的bean 类对象
     * @return true:成功
     */
    public static boolean registryBeanDefinition(BeanDefinitionRegistry registry, Class<?> beanClass) {
        return registerBeanDefinition(registry, null, beanClass, null, new Object());
    }

    /**
     * 注册bean到Spring容器中<br/>
     *
     * @param registry        注册器
     * @param beanClass       需要注册的bean 类对象
     * @param constructorArgs 构造参数对象集合
     * @return true:成功
     */
    public static boolean registryBeanDefinition(BeanDefinitionRegistry registry, Class<?> beanClass, Object... constructorArgs) {
        return registerBeanDefinition(registry, null, beanClass, null, constructorArgs);
    }


    /**
     * 注册bean到Spring容器中<br/>
     *
     * @param registry        注册器
     * @param beanName        需要注册的bean名称
     * @param beanClass       需要注册的bean 类对象
     * @param constructorArgs 构造参数对象集合
     * @return true:成功
     */
    public static boolean registryBeanDefinition(BeanDefinitionRegistry registry, String beanName, Class<?> beanClass, Object... constructorArgs) {
        return registerBeanDefinition(registry, beanName, beanClass, null, constructorArgs);
    }

    /**
     * 注册bean到Spring容器中<br/>>
     *
     * @param registry            注册器
     * @param beanName            需要注册的bean名称
     * @param beanClass           需要注册的bean 类对象
     * @param extraPropertyValues 额外参数集合
     * @param constructorArgs     构造参数对象集合
     * @return true:成功
     */
    public static boolean registerBeanDefinition(BeanDefinitionRegistry registry, String beanName,
                                                 Class<?> beanClass, Map<String, Object> extraPropertyValues, Object... constructorArgs) {
        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(beanClass);
        //构造参数
        if (constructorArgs != null) {
            for (Object obj : constructorArgs) {
                beanDefinitionBuilder.addConstructorArgValue(obj);
            }
        }
        AbstractBeanDefinition beanDefinition = beanDefinitionBuilder.getBeanDefinition();

        if (StringUtils.isBlank(beanName)) {
            beanName = ClassUtils.getShortNameAsProperty(beanClass);
        }

        //是否存在
        if (registry.containsBeanDefinition(beanName)) {
            return false;
        }

        //注册条件判断
        String[] candidates = registry.getBeanDefinitionNames();
        for (String candidate : candidates) {
            BeanDefinition candidateBeanDefinition = registry.getBeanDefinition(candidate);
            if (Objects.equals(candidateBeanDefinition.getBeanClassName(), beanClass.getName())) {
                return false;
            }
        }

        //注册
        if (extraPropertyValues != null) {
            for (Map.Entry<String, Object> entry : extraPropertyValues.entrySet()) {
                beanDefinition.getPropertyValues().add(entry.getKey(), entry.getValue());
            }
        }

        registry.registerBeanDefinition(beanName, beanDefinition);
        return true;
    }

}

ClassScaner

java


import org.springframework.context.ApplicationContext;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternUtils;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.ClassMetadata;
import org.springframework.core.type.classreading.CachingMetadataReaderFactory;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.util.SystemPropertyUtils;

import java.io.IOException;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.List;

/**
 * 类扫描器
 * @author sunwen
 * @since 2019/5/17
 */
public class ClassScaner {

    public static <T> List<Class<? extends T>> scan(String basePackage, Class<T> clazz) throws Exception{
        ApplicationContext context = SpringContextUtil.getApplicationContext();
        if(context == null){
            throw new Exception("spring context has not inited");
        }
        return scan(context, basePackage, clazz);
    }

    /**
     * 扫描指定包下的clazz所有子类（排除抽象类和接口）
     * @author sunwen
     * @since 2020/8/19
     */
    public static <T> List<Class<? extends T>> scan(ResourceLoader resourceLoader, String basePackage, Class<T> clazz)
            throws IOException, ClassNotFoundException {
        List<Class<? extends T>> list = new ArrayList<>();
        ResourcePatternResolver resolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
        MetadataReaderFactory metaReader = new CachingMetadataReaderFactory(resourceLoader);
        String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
                + org.springframework.util.ClassUtils.convertClassNameToResourcePath(
                        SystemPropertyUtils.resolvePlaceholders(basePackage))
                + "/**/*.class";
        Resource[] resources = resolver.getResources(packageSearchPath);
        for (Resource r : resources) {
            MetadataReader reader = metaReader.getMetadataReader(r);
            ClassMetadata classMetadata = reader.getClassMetadata();
            if(classMetadata.isInterface() || classMetadata.isAbstract()){
                continue;
            }
            Class c = Class.forName(classMetadata.getClassName());
            if (clazz.isAssignableFrom(c) && !clazz.equals(c)){
                list.add(c);
            }
        }
        return list;
    }

    /**
     * 扫描指定包下的clazz注解的类（排除抽象类和接口）
     * @author sunwen
     * @since 2020/8/19
     */
    public static List<ClassMetadata> scanAnnotation(ResourceLoader resourceLoader, String basePackage, Class<? extends Annotation> clazz)
            throws IOException {
        List<ClassMetadata> list = new ArrayList<>();
        ResourcePatternResolver resolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
        MetadataReaderFactory metaReader = new CachingMetadataReaderFactory(resourceLoader);
        String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX
                + org.springframework.util.ClassUtils.convertClassNameToResourcePath(
                SystemPropertyUtils.resolvePlaceholders(basePackage))
                + "/**/*.class";
        Resource[] resources = resolver.getResources(packageSearchPath);
        String annotationName = clazz.getName();
        for (Resource r : resources) {
            MetadataReader reader = metaReader.getMetadataReader(r);
            ClassMetadata classMetadata = reader.getClassMetadata();
            if(classMetadata.isInterface() || classMetadata.isAbstract()){
                continue;
            }
            AnnotationMetadata annotationMetadata = reader.getAnnotationMetadata();
            if(annotationMetadata.hasAnnotation(annotationName) || annotationMetadata.hasMetaAnnotation(annotationName)){
                list.add(classMetadata);
            }
        }
        return list;
    }
}

HttpPathUtil

java


import com.commnetsoft.commons.utils.StringUtils;
import org.springframework.util.AntPathMatcher;

/**
 * HTTP路径工具类
 *
 * @author Brack.zhu
 * @date 2020/11/4
 */
public class HttpPathUtil {

    private HttpPathUtil() {
    }

    private static AntPathMatcher antPathMatcher = new AntPathMatcher();

    /**
     * 根据路径匹配器的匹配策略匹配指定的路径
     *
     * @param path    路径
     * @param pattern 匹配策略
     * @return true:匹配成功
     */
    public static boolean match(String path,String pattern) {
        if (StringUtils.isNoneBlank(pattern, path)) {
            return antPathMatcher.match(pattern, path);
        }
        return false;
    }

    /**
     * 根据路径匹配器的匹配策略匹配指定的路径
     *
     * @param path     路径
     * @param patterns 匹配策略集合
     * @return true:匹配成功
     */
    public static boolean match(String path, String... patterns) {
        if (StringUtils.isNoneBlank(path) && null != patterns) {
            for (String pattern : patterns) {
                if (match(path, pattern)) {
                    return true;
                }
            }
        }
        return false;
    }

}

HttpRequestUtil

java


import com.commnetsoft.auth.model.HttpReqHead;
import com.commnetsoft.auth.model.HttpRouteHead;
import com.commnetsoft.auth.model.LoginEntity;
import com.commnetsoft.commons.utils.IpUtils;
import com.commnetsoft.data.constant.Entity;
import org.apache.commons.lang3.StringUtils;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;

/**
 * HTTP 请求工具类
 * @author Brack.zhu
 * @date 2019/3/27
 */
public class HttpRequestUtil {

    private HttpRequestUtil() {}

    /**
     * 获取登录用户对应的用户模型id
     * @param request
     * @return
     */
    public static String getHeaderUserId(HttpServletRequest request) {
        LoginEntity entity = getHeaderEntity(request);
        if(entity != null && Entity.user.getValue().equals(entity.getNs())){
            return entity.getId();
        }
        return null;
    }

    /**
     * 获取请求头中的本地IDM的UUID,只有认证成功后的请求才有<br/>
     * @param request
     * @return
     */
    public static String getHeaderIdmuid(HttpServletRequest request) {
        return getHeader(request, HttpRouteHead.idmuid.getValue());
    }

    /**
     * 获取请求头中的开放平台servicecode,只有开放平台认证成功后的请求才有<br/>
     * @param request
     * @return
     */
    public static String getHeaderServiceCode(HttpServletRequest request) {
        return getHeader(request, HttpReqHead.servicecode.getValue());
    }

    /**
     * 获取当前登录实体
     * @author sunwen
     * @since 2020/7/8
     */
    public static LoginEntity getHeaderEntity(HttpServletRequest request) {
        String id = getHeader(request, HttpRouteHead.entityId.getValue());
        if(StringUtils.isEmpty(id)){
            return null;
        }
        String ns = getHeader(request, HttpRouteHead.entityNs.getValue());
        return new LoginEntity(ns, id);
    }

    /**
     * 获取请求头中的信息,内容转换成UTF-8<br/>
     *
     * @param request
     * @param key
     * @return
     */
    public static String getHeader(HttpServletRequest request,String key) {
        String keyVal = request.getHeader(key);
        if(keyVal != null) {
            try {
                keyVal = URLDecoder.decode(keyVal, StandardCharsets.UTF_8.name());
            } catch (UnsupportedEncodingException e) {
                //ignore
            }
        }
        return keyVal;
    }


    /**
     * 获取请求头中JWT信息,只有认证成功后的请求才有<br/>
     *
     * @param request
     * @return
     */
    public static String getHeaderJWT(HttpServletRequest request) {
        String token=request.getHeader(HttpReqHead.token.getValue());
        if(StringUtils.isBlank(token)){
            token=request.getHeader(HttpReqHead.token_old.getValue());
        }
        return token;
    }



    /**
     * 获取Request请求对象
     *
     * @return
     */
    public static HttpServletRequest getRequest() {
        ServletRequestAttributes servletRequestAttributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = servletRequestAttributes.getRequest();
        return request;
    }

    /**
     * 判断当前设备是否为手机端
     * @param request
     * @return
     */
    public static boolean isMobileDevice(HttpServletRequest request){
        String userAgent = request.getHeader("User-Agent");
        boolean isMoblie = false;
        String[] mobileAgents = { "iphone", "android","ipad", "phone", "windows phone"};
        if (StringUtils.isNotEmpty(userAgent)) {
            userAgent = userAgent.toLowerCase();
            for (String mobileAgent : mobileAgents) {
                if (userAgent.contains(mobileAgent)) {
                    isMoblie = true;
                    break;
                }
            }
        }
        return isMoblie;
    }

    /**
     * 根据request获取ip地址
     * @param request
     * @return
     */
    public static String getIpAddr(HttpServletRequest request) {
        String ip = request.getHeader("x-forwarded-for");
        if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("Proxy-Client-IP");
        }
        if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getHeader("WL-Proxy-Client-IP");
        }
        if(ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        //特殊处理ip可能有多个 取第一个
        if(StringUtils.contains(ip, ",")){
            ip = StringUtils.substringBefore(ip, ",");
        }
        //防止头信息被注入，对ip处理
        if(false == IpUtils.isIp(ip)){
            ip = "";
        }
        return ip;
    }


    /**
     * 获取指定Cookie对象
     * @param request
     * @param name
     * @return
     */
    public static Cookie getCookie(HttpServletRequest request,String name){
        Cookie[] cookies = request.getCookies();
        if(cookies == null || cookies.length <= 0) {
            return null;
        }
        for(int i = 0; i < cookies.length; i++){
            if(cookies[i].getName().equalsIgnoreCase(name)){
               return cookies[i];
            }
        }
        return null;
    }

    /**
     * 获取Cookie指定值
     * @param request
     * @param name
     * @return
     */
    public static String getCookieVal(HttpServletRequest request,String name){
        Cookie cookie=getCookie(request, name);
        if(null!=cookie){
            return cookie.getValue();
        }
        return null;
    }
}

HttpResponseUtil

java


import com.commnetsoft.commons.utils.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.MediaType;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;

/**
 * @ClassName HttpResponseUtil
 * @Author wuzm
 * @Date 2019/4/18 14:54
 * @Version 1.0
 */
public class HttpResponseUtil {
    private static final Logger log = LoggerFactory.getLogger(HttpResponseUtil.class);
    private HttpResponseUtil() {
    }

    public transient final static String DATATYPE_XML = "xml";
    public transient final static String DATATYPE_JSON = "json";

    /**
     * 输出xml格式到页面
     * @Param response
     * @Param content
     * @Param charSet
     * @Return void
     * @Author wuzm
     * Date 2019/4/18 16:47
     */
    public static void renderXML(HttpServletResponse response, String content, Charset charSet) {
        render(response,content, MediaType.TEXT_XML_VALUE,charSet);
    }

    /**
     * 输出json格式到页面
     * @Param response
     * @Param content
     * @Param charSet
     * @Return void
     * @Author wuzm
     * Date 2019/4/18 16:48
     */
    public static void renderJson(HttpServletResponse response, String content, Charset charSet) {
        render(response, content, MediaType.APPLICATION_JSON_VALUE,charSet);
    }

    /**
     * 输出txt格式到页面
     * @Param response
     * @Param content
     * @Param charSet
     * @Return void
     * @Author wuzm
     * Date 2019/4/18 16:48
     */
    public static void renderText(HttpServletResponse response, String content, Charset charSet) {
        render(response,content, MediaType.TEXT_PLAIN_VALUE,charSet);
    }

    /**
     * 输出html格式到页面
     * @Param response
     * @Param content
     * @Param charSet
     * @Return void
     * @Author wuzm
     * Date 2019/4/18 16:48
     */
    public static void renderHtml(HttpServletResponse response, String content, Charset charSet) {
        render(response,content,  MediaType.TEXT_HTML_VALUE,charSet);
    }

    /**
     * 输出js格式到页面
     * @Param response
     * @Param content
     * @Param charSet
     * @Return void
     * @Author wuzm
     * Date 2019/4/18 16:48
     */
    public static void renderJs(HttpServletResponse response, String content, Charset charSet) {
        render(response,content, "application/javascript", charSet);
    }

    /**
     * 用指定格式将内容写出到页面,默认使用UTF-8格式
     * @Param response
     * @Param content
     * @Param mimeType
     * @Return void
     * @Author wuzm
     * Date 2019/4/18 16:28
     */
    public static void render(HttpServletResponse response, String content, String mimeType, Charset charSet){
        try {
            if(null == charSet){
                charSet = StandardCharsets.UTF_8;
            }
            response.setContentType(mimeType+";charset="+charSet.displayName());
            response.setContentLength(content.getBytes(StandardCharsets.UTF_8).length);
            response.getWriter().write(content);
        } catch (IOException e) {
            log.error("response写入(content={}，contentType={})异常:{}", content, mimeType, e);
        }
    }

    /**
     * 根据datatype的不同设置对应的返回格式,默认返回text格式
     * @param response
     * @param text
     * @param contentType
     */
    public static void contextType(HttpServletResponse response,String text,String contentType){
        if(StringUtils.equalsIgnoreCase(DATATYPE_XML, contentType)){
            renderXML(response,text,null);
        }else if(StringUtils.equalsIgnoreCase(DATATYPE_JSON, contentType)){
            renderJson(response,text,null);
        }else {
            renderText(response, text,null);
        }
    }

}

PagerUtils

java


import com.commnetsoft.commons.Pager;
import com.commnetsoft.commons.utils.BeanUtils;
import com.commnetsoft.commons.utils.BeanUtils.BeanCopier;

import java.util.List;

public class PagerUtils {

    /**
     * 通过Bean拷贝方式转换页面数据模型
     * @author sunwen
     * date 2019/4/26
     */
    public static <S, T> Pager<T> cast(Pager<S> pager, Class<T> clazz){
        return cast(pager, clazz, null);
    }

    /**
     * 通过Bean拷贝方式转换页面数据模型
     * @author sunwen
     * date 2019/4/26
     */
    public static <S, T> Pager<T> cast(Pager<S> pager, Class<T> clazz, BeanCopier<S, T> copier){
        List<T> tRows = null;
        List<S> rows = pager.getRows();
        if(rows != null){
            tRows = BeanUtils.batchCopyProperties(rows, clazz, copier);
        }
        Pager<T> tPager = (Pager<T>) pager;
        tPager.setRows(tRows);
        return tPager;
    }
}

SpElUtil

java


import com.commnetsoft.commons.utils.StringUtils;
import com.commnetsoft.core.CommonError;
import com.commnetsoft.exception.MicroRuntimeException;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanExpressionContext;
import org.springframework.beans.factory.config.BeanExpressionResolver;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;

import java.lang.reflect.Method;

/**
 * Spel表达式工具类
 *
 * @author Brack.zhu
 * @date 2020/5/27
 */
public class SpElUtil {

    private static BeanExpressionResolver resolver;

    private static BeanExpressionContext expressionContext;

    private static SpelExpressionParser parser = new SpelExpressionParser();

    private static LocalVariableTableParameterNameDiscoverer methodDiscoverer = new LocalVariableTableParameterNameDiscoverer();


    private SpElUtil() {

    }

    /**
     * 解析Spel表达式---针对Spring代理Bean
     *
     * @param expressionStr SpEL表达式
     * @param <T>           返回类型结果
     * @return 表达式值
     * @throws MicroRuntimeException
     * @throws BeansException
     */
    public static <T> T evaluate(String expressionStr) throws MicroRuntimeException, BeansException {
        try {
            if (null == resolver) {
                ConfigurableBeanFactory beanFactory = (ConfigurableBeanFactory) SpringContextUtil.getApplicationContext().getAutowireCapableBeanFactory();
                resolver = beanFactory.getBeanExpressionResolver();
                expressionContext = new BeanExpressionContext(beanFactory, null);
            }
            Object rs = resolver.evaluate(expressionStr, expressionContext);
            return (T) rs;
        } catch (BeansException be) {
            throw be;
        } catch (ClassCastException cce) {
            throw new MicroRuntimeException(CommonError.illegal_operation.getCode(), "SpEl表达式解析返回结果转换失败:" + expressionStr, "", cce);
        } catch (Exception e) {
            throw new MicroRuntimeException(CommonError.internal_error.getCode(), "SpEl表达式解析失败:" + expressionStr, "", e);
        }
    }

    /**
     * 解析Spel表达式---针对Spring代理Method
     *
     * @param expressionStr     SpEL表达式
     * @param evaluationContext Spel上下文对象,{@link #methodBindParam(Method, Object[])}
     * @param <T>               返回类型结果
     * @return 表达式值
     * @throws MicroRuntimeException
     * @throws BeansException
     */
    public static <T> T evaluate(String expressionStr, EvaluationContext evaluationContext) throws MicroRuntimeException {
        try {
            if (null != evaluationContext && StringUtils.isNotBlank(expressionStr)) {
                Expression expression = parser.parseExpression(expressionStr);
                Object rs = expression.getValue(evaluationContext);
                return (T) rs;
            }
        } catch (Exception e) {
            throw new MicroRuntimeException(CommonError.internal_error.getCode(), "SpEl表达式解析失败:" + expressionStr, "", e);
        }
        return null;
    }


    /**
     * 将方法的参数名和参数值绑定，用于获取方法SPEL值--针对Spring代理Method
     *
     * @param method 方法，根据方法获取参数名
     * @param args   方法的参数值
     * @return SPEL上下文对象
     */
    public static EvaluationContext methodBindParam(Method method, Object[] args) {
        //获取方法的参数名
        String[] params = methodDiscoverer.getParameterNames(method);
        //将参数名与参数值对应起来
        EvaluationContext context = new StandardEvaluationContext();
        if (null != params) {
            for (int len = 0; len < params.length; len++) {
                context.setVariable(params[len], args[len]);
            }
        }
        return context;
    }

}

SpringContextUtil

java


import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.core.env.Environment;
import org.springframework.util.ClassUtils;

import java.util.Map;

/**
 * Spring 上下文工具类<br/>
 * 注意：如果在ApplicationContext未准备好的情况下会获取失败的情况，需要考虑先后顺序
 *
 * @author Brack.zhu
 * @date 2019/4/4
 */

public class SpringContextUtil{

    /**
     * Spring应用上下文环境
     */
    private static ApplicationContext applicationContext;

    private  SpringContextUtil(){

    }

    /**
     * 外部设置由初始化时
     * @param context
     */
    public static void init(ApplicationContext context){
        applicationContext=context;
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    public static Environment getEnvironment() {
        return applicationContext.getEnvironment();
    }

    /**
     * 获取对象
     * 例如: getBean("userService")//注意： 类名首字母一定要小写！
     */
    public static <T> T getBean(String beanId) throws BeansException {
        return (T) applicationContext.getBean(beanId);
    }

    /**
     * 获取对象
     */
    public static <T> T getBean(Class<T> clazz) throws BeansException {
        return applicationContext.getBean(clazz);
    }

    /**
     * 获取对象
     */
    public static <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException {
        return applicationContext.getBeansOfType(type);
    }

    /**
     * 获取Spring容器对象名称集合
     * @return
     */
    public static String[] getBeanNames(){
        return applicationContext.getBeanDefinitionNames();
    }

    /**
     * 判断指定bean名称Bean容器是否包含
     *
     * @param beanName
     * @return
     */
    public static boolean containsBean(String beanName) {
        if (null == applicationContext) {
            //未准备好
            return false;
        }
        return applicationContext.containsBean(beanName);
    }

    /**
     * 判断指定Class默认名称Bean容器是否包含
     *
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> boolean containsBean(Class<T> clazz) {
        String beanDefName = ClassUtils.getShortNameAsProperty(clazz);
        return containsBean(beanDefName);
    }

    /**
     * 获取Environment参数
     * @param key
     * @return
     */
    public static String getEnvProperty(String key) {
        return getEnvironment().getProperty(key);
    }


}

TemplateUtil

java


import jetbrick.template.JetEngine;
import jetbrick.template.JetTemplate;

import java.io.StringWriter;
import java.util.HashMap;
import java.util.Map;

/**
 * 模板静态化工具类
 * @ClassName TemplateUtil
 * @Author wuzm
 * @Date 2019/8/16 15:43
 * @Version 1.0
 */
public class TemplateUtil {

    private static JetEngine engine = JetEngine.create();

    /**
     * 根据使用模板源代码生成静态字符串。
     * @Param source
     * @Param map
     * @Return java.lang.String
     * @Author wuzm
     * Date 2019/8/16 15:45
     */
    public static String buildTemplate(String source, Map<String,Object> map){
        JetTemplate template = engine.createTemplate(source);
        StringWriter sw = new StringWriter();
        template.render(map, sw);
        return sw.toString();
    }

    public static void main(String[] args) {
        String msg = "您好！${name}:\r\n  您的手机号${mobile}本月余额${balance}元。";
        Map<String, Object> map = new HashMap<>();
        map.put("name", "张三");
        map.put("mobile", "15777777777");
        map.put("balance", 100);
        String newmsg = buildTemplate(msg, map);
        System.out.println(newmsg);
    }

}

AOPUtil ​

ApplicationUtil ​

BeanRegistryUtil ​

ClassScaner ​

HttpPathUtil ​

HttpRequestUtil ​

HttpResponseUtil ​

PagerUtils ​

SpElUtil ​

SpringContextUtil ​

TemplateUtil ​

AOPUtil

ApplicationUtil

BeanRegistryUtil

ClassScaner

HttpPathUtil

HttpRequestUtil

HttpResponseUtil

PagerUtils

SpElUtil

SpringContextUtil

TemplateUtil