精华内容
下载资源
问答
  • 文章目录JDBC工具类1 工具类的代码实现相关变量使用ResourceBundle 进行资源的绑定,主要是绑定到 jdbc.properties 文件,方便将这个配置文件里面的相关配置读取出来(1)(2)加载驱动关闭资源2 工具类代码实现所有代码...

    思维导图

    在这里插入图片描述

    Github 地址获取原始思维导图文件

    https://github.com/YIMEng-0/JavaPlus/tree/main/javaSE%E5%A4%8D%E4%B9%A0%E5%87%86%E5%A4%87/java%E5%9F%BA%E7%A1%80

    如有帮助 欢迎 star

    目前整理的 xmind

    在这里插入图片描述

    JDBC工具类

    1 工具类的代码实现

    相关变量

    定义四个变量

    • driver

    数据库的驱动,让程序可以使用数据库
    com.mysql.jdbc.Driver

    • url

    具体的数据库的位置

    jdbc:mysql://localhost:3306/data

    • username
      可以访问数据库的用户名
    • password

    使用ResourceBundle 进行资源的绑定,主要是绑定到 jdbc.properties 文件,方便将这个配置文件里面的相关配置读取出来

    static { // 在类加载的时候,只需要执行一次即可
            ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
            driver = bundle.getString("driver");
            url = bundle.getString("url");
            username = bundle.getString("username");
            password = bundle.getString("password");
        }
    

    (1)(2)加载驱动

    • 建立链接,建立链接的时候,把数据库的 url 用户名字以及密码传递进去
    public static Connection getConnection() throws SQLException {
            Connection conn = null;
            try {
                Class.forName(driver);
                conn = DriverManager.getConnection(url, username, password);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            return conn;
        }
    

    关闭资源

    public static void close(Connection conn, Statement ps, ResultSet rs) {
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
    
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
    
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    
    - 关闭资源方法需要传递的三个参数,conn,Statement,ResultSet
    

    2 工具类代码实现所有代码

    package com.luobin.utils;

    /**
     * @author Doraemon
     * @date 2021/12/12 12:08 下午
     * @version 1.0
     */
    
    import java.sql.*;
    import java.util.ResourceBundle;
    
    /**
     * JDBC 工具类,用来简化 JDBC 编程
     */
    public class DBUtil {
        /**
         * 工具类中的属性、方法都是私有的,
         * 因为工具类中的方法都是静态的,不需要直接的new 对象,直接使用类名字进行调用即可;
         */
    
        //私有变量
        private static String driver;
        private static String url;
        private static String username;
        private static String password;
    
    
        static { // 在类加载的时候,只需要执行一次即可
            ResourceBundle bundle = ResourceBundle.getBundle("jdbc");
            driver = bundle.getString("driver");
            url = bundle.getString("url");
            username = bundle.getString("username");
            password = bundle.getString("password");
        }
    
        public static Connection getConnection() throws SQLException {
            Connection conn = null;
            try {
                Class.forName(driver);
                conn = DriverManager.getConnection(url, username, password);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            return conn;
        }
    
        /**
         * 关闭资源
         * @param conn 连接对象
         * @param ps 数据库操作对象
         * @param rs 结果集
         */
        public static void close(Connection conn, Statement ps, ResultSet rs) {
            if (rs != null) {
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
    
            if (ps != null) {
                try {
                    ps.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
    
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    

    3 调用工具类的代码实现

    创建进行数据库交互的相关变量

    • Connection
    • PrepareStatement
    • ResultSet

    调用静态方法进行连接的建立

    • conn = DBUtil.getConnection();

    (3)建立sql 语句,将建立的sql 语句进行预编译,得到预编译环境

    • String sql = “select deptno,dname,loc from dept”;
      ps = conn.prepareStatement(sql);

    (4)执行预编译得到处理结果

    • PrepareStatement是SQL语句预编译对象,当我们执行:preparedStatement = connection.prepareStatement(sql);这一行代码获取PrepareStatement对象的时候就会把传进去的sql语句进行编译并且加载进如内存中,在接下来的操作中我们只需要对sql语句中的占位符:?进行赋值,这样sql语句就不需要再次重新编译,这是与statement对象的最主要的差别

      • rs = ps.executeQuery();

    (5)对处理结果进行处理

    while (rs.next()) {
                    String deptno = rs.getString("deptno");
                    String dname = rs.getString("dname");
                    String loc = rs.getString("loc");
                    }
    

    (6)释放资源

    • DBUtil.close(conn, ps, rs);

    4 调用工具类的代码实现

    package com.luobin.oa.web.action;

     /**
     * @author Doraemon
     * @date 2021/12/12 2:19 下午
     * @version 1.0
     */
    
    import com.luobin.utils.DBUtil;
    
    import javax.servlet.*;
    import javax.servlet.http.*;
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    public class DeptListServlet extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            Connection conn = null;
            PreparedStatement ps = null;
            ResultSet rs = null; 
    
            try {
                // 获取连接
                conn = DBUtil.getConnection(); // 加载驱动,获取连接,完成 1 2 步 getConnection方法里面有两步
               
                String sql = "select deptno,dname,loc from dept";
                ps = conn.prepareStatement(sql); // 获取预编译数据库操作对象,完成第 3 步
             
                rs = ps.executeQuery(); // 执行 sql 完成 4 步
    
                int i = 0;
                // 处理查询结果集合 完成第 5 步
                while (rs.next()) { // rs 里面的东西就是查询到的表格里面的东西,没有表头的一个表的部分数据
                    String deptno = rs.getString("deptno");
                    String dname = rs.getString("dname");
                    String loc = rs.getString("loc");
    
                    // 下面的界面进行动态的展示
      
                }
    
            } catch (SQLException e) {
                e.printStackTrace();
            } finally { // 资源释放完成第 6 步
                DBUtil.close(conn, ps, rs);
            }
        }
    }
    

    5 sql 注入以及解决的方式

    怎么注入进去的

    • 客户端在自己电脑操作时候,有一定的输入操作,这个输入操作中可能会有一些特殊符号的输入,把特殊的符号输入进去之后,会编译到SQL语句中,进而破坏正常的SQL语句的结构,导致安全漏洞问题,攻击者就可以执行计划外的命令或访问未被授权的数据
    String sql = "select * from user_table where username=
    ' "+userName+" ' and password=' "+password+" '";
    

    –当输入了上面的用户名和密码,上面的SQL语句变成:

    SELECT * FROM user_table WHERE username='’or 1 = 1 -- and password='
    --分析SQL语句:
    --条件后面username=”or 1=1 用户名等于 ” 或1=1 那么这个条件一定会成功;
    
    --然后后面加两个-,这意味着注释,它将后面的语句注释,让他们不起作用,这样语句永远都--能正确执行,用户轻易骗过系统,获取合法身份。
    --这还是比较温柔的,如果是执行
    SELECT * FROM user_table WHERE
    username='' ;DROP DATABASE (DB Name) --' and password=''
    --其后果可想而知…
    

    怎么解决注入问题?

    • 参数化查询,使用了预编译的数据库操作对象,提前将SQL语句编译好,里面设置变量集,用户输入的部分作为变量的赋值,不参与到SQL语句的编译,没有破坏SQL语句结构,抵御了SQL注入

    小结

    1、通过了工具类在进行连接的时候,进行资源释放的时候,会简化代码

    2、在工具类里面是没有写 sql 语句和解析的,因为在工具类里面不执行语句

    展开全文
  • Java对象映射工具类封装

    千次阅读 2021-11-18 14:11:34
    文章主要记录一下工作中封装的对象转换工具类 /** * Spring的BeanUtils只能映射类型相同的属性,无法满足将Date转字符串,枚举类型转换等需求 * 所以将Spring的BeanUtils源码复制出来,自己扩展了映射逻辑 */ ...

    文章主要记录一下工作中封装的对象转换工具类

    /**
     * Spring的BeanUtils只能映射类型相同的属性,无法满足将Date转字符串,枚举类型转换等需求
     * 所以将Spring的BeanUtils源码复制出来,自己扩展了映射逻辑
     */
    public class BeanMapUtil {
        /**
         * 缓存字段上使用DateFormat注解配置的日期格式,key为包名+类名+字段名,value为使用DateFormat注解配置的日期格式
         */
        private static final Map<String, String> DATE_FORMAT_CACHE = new ConcurrentHashMap<>();
        private static final Logger LOGGER = LoggerFactory.getLogger(BeanMapUtil.class);
    
        private BeanMapUtil() {
        }
    
        /**
         * <p>将集合转换成其他类型的集合,并将每个元素的属性根据名称拷贝到新集合的元素中。如果遇到属性类型不一致,会自动根据类型进行转换</p>
         * <p>通常用于将pojo转成VO</p>
         * <p>在转换时,如果字段同名但类型不一致,还支持日期类型自动转成yyyy-MM-dd HH:mm:ss类型的字符串、yyyy-MM-dd HH:mm:ss格式的字符串字段转成日期类型,将枚举代码转换为枚举类型、将所有基本数据类型自动转为字符串类型功能</p>
         *
         * @param originalList 原始的集合
         * @param resultType   新集合元素的类对象
         * @param <T>          新集合元素的类型
         * @return 新集合
         */
        @SuppressWarnings("unchecked")
        public static <T> List<T> convertList(List<?> originalList, Class<T> resultType) {
            return convertList(originalList, resultType, (String[]) null);
        }
    
        /**
         * <p>将集合转换成其他类型的集合,并将每个元素的属性根据名称拷贝到新集合的元素中。如果遇到属性类型不一致,会自动根据类型进行转换</p>
         * <p>通常用于将pojo转成VO</p>
         * <p>在转换时,如果字段同名但类型不一致,还支持日期类型自动转成yyyy-MM-dd HH:mm:ss类型的字符串、yyyy-MM-dd HH:mm:ss格式的字符串字段转成日期类型,将枚举代码转换为枚举类型、将所有基本数据类型自动转为字符串类型功能</p>
         *
         * @param originalList     原始的集合
         * @param resultType       新集合元素的类对象
         * @param ignoreProperties array of property names to ignore
         * @param <T>              新集合元素的类型
         * @return 新集合
         */
        @SuppressWarnings("unchecked")
        public static <T> List<T> convertList(List<?> originalList, Class<T> resultType,
                                              @Nullable String... ignoreProperties) {
            if (CollectionUtils.isEmpty(originalList)) {
                return Lists.newArrayList();
            }
    
            // 类型相同,直接返回,不再通过反射复制属性
            if (resultType.isAssignableFrom(originalList.get(0).getClass())) {
                return (List<T>) originalList;
            }
    
            // 将集合转换成其他类型的集合,并将每个元素的属性根据名称拷贝到新集合的元素中
            List<T> result = new ArrayList<>(originalList.size());
            for (Object o : originalList) {
                T newObject = BeanUtils.instantiateClass(resultType);
                copyProperties(o, newObject, ignoreProperties);
                result.add(newObject);
            }
            return result;
        }
    
        /**
         * 将对象转换成其他类型的对象,并将属性根据名称拷贝到新对象。如果遇到属性类型不一致,会自动根据类型进行转换
         * 在转换时,如果字段同名但类型不一致,还支持日期类型自动转成yyyy-MM-dd HH:mm:ss类型的字符串、yyyy-MM-dd HH:mm:ss格式的字符串字段转成日期类型,将枚举代码转换为枚举类型、将所有基本数据类型自动转为字符串类型功能
         *
         * @param source     原始对象
         * @param resultType 目标类型的类对象
         * @param <T>        目标类型
         * @return 新对象
         */
        @SuppressWarnings("unchecked")
        public static <T> T convertObject(Object source, Class<T> resultType) {
            return convertObject(source, resultType, (String[]) null);
        }
    
        /**
         * 将对象转换成其他类型的对象,并将属性根据名称拷贝到新对象。如果遇到属性类型不一致,会自动根据类型进行转换
         * 在转换时,如果字段同名但类型不一致,还支持日期类型自动转成yyyy-MM-dd HH:mm:ss类型的字符串、yyyy-MM-dd HH:mm:ss格式的字符串字段转成日期类型,将枚举代码转换为枚举类型、将所有基本数据类型自动转为字符串类型功能
         *
         * @param source           原始对象
         * @param resultType       目标类型的类对象
         * @param ignoreProperties array of property names to ignore
         * @param <T>              目标类型
         * @return 新对象
         */
        @SuppressWarnings("unchecked")
        public static <T> T convertObject(Object source, Class<T> resultType,
                                          @Nullable String... ignoreProperties) {
            if (source == null) {
                return null;
            }
    
            // 类型相同,直接返回,不再通过反射复制属性
            if (resultType.isAssignableFrom(source.getClass())) {
                return (T) source;
            }
    
            // 转换类型
            T result = BeanUtils.instantiateClass(resultType);
            copyProperties(source, result, ignoreProperties);
            return result;
        }
    
        /**
         * Copy the property values of the given source bean into the target bean.
         * <p>Note: The source and target classes do not have to match or even be derived
         * from each other, as long as the properties match. Any bean properties that the
         * source bean exposes but the target bean does not will silently be ignored.
         * <p>This is just a convenience method. For more complex transfer needs,
         * consider using a full BeanWrapper.
         *
         * @param source the source bean
         * @param target the target bean
         * @see BeanWrapper
         */
        public static void copyProperties(Object source, Object target) {
            copyProperties(source, target, (String[]) null);
        }
    
        /**
         * 将Map转成javabean
         *
         * @param map       map
         * @param beanClass 目标类型的类对象
         * @param <T>       目标类型
         * @return javabean
         */
        public static <T> T mapToObject(Map<String, Object> map, Class<T> beanClass) {
            if (map == null) {
                return null;
            }
    
            T obj;
            try {
                obj = beanClass.newInstance();
    
                BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
                PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
                for (PropertyDescriptor property : propertyDescriptors) {
                    Method setter = property.getWriteMethod();
                    if (setter != null) {
                        setter.invoke(obj, map.get(property.getName()));
                    }
                }
            } catch (IllegalAccessException | IntrospectionException | InstantiationException | InvocationTargetException e) {
                throw new IllegalStateException(
                        "Could not transform " + map + " to " + beanClass.getName(), e);
            }
    
            return obj;
        }
    
        /**
         * 将javabean转成Map
         *
         * @param obj javabean
         * @return 转换结果
         */
        @SuppressWarnings("unchecked")
        public static Map<String, Object> objectToMap(Object obj) {
            if (obj == null) {
                return null;
            } else if (obj instanceof Map) {
                return (Map<String, Object>) obj;
            }
    
            Map<String, Object> map = new HashMap<>(32);
    
            try {
                BeanInfo beanInfo = Introspector.getBeanInfo(obj.getClass());
                PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
                for (PropertyDescriptor property : propertyDescriptors) {
                    String key = property.getName();
                    if (key.compareToIgnoreCase("class") == 0) {
                        continue;
                    }
                    Method getter = property.getReadMethod();
                    Object value = getter != null ? getter.invoke(obj) : null;
                    map.put(key, value);
                }
            } catch (IllegalAccessException | IntrospectionException | InvocationTargetException e) {
                throw new IllegalStateException(
                        "Could not transform " + JSON.toJSONString(obj) + " to map", e);
            }
    
            return map;
        }
    
        /**
         * Copy the property values of the given source bean into the given target bean.
         * <p>Note: The source and target classes do not have to match or even be derived
         * from each other, as long as the properties match. Any bean properties that the
         * source bean exposes but the target bean does not will silently be ignored.
         *
         * @param source           the source bean
         * @param target           the target bean
         * @param ignoreProperties array of property names to ignore
         * @see BeanWrapper
         */
        public static void copyProperties(Object source, Object target,
                                          @Nullable String... ignoreProperties) {
    
            Assert.notNull(source, "Source must not be null");
            Assert.notNull(target, "Target must not be null");
    
            Class<?> targetClass = target.getClass();
            PropertyDescriptor[] targetPds = BeanUtils.getPropertyDescriptors(targetClass);
            List<String> ignoreList = (ignoreProperties != null ? Arrays.asList(ignoreProperties) : null);
    
            for (PropertyDescriptor targetPd : targetPds) {
                Method writeMethod = targetPd.getWriteMethod();
                if (writeMethod != null && (ignoreList == null || !ignoreList.contains(targetPd.getName()))) {
                    PropertyDescriptor sourcePd = BeanUtils.getPropertyDescriptor(source.getClass(), targetPd.getName());
                    if (sourcePd != null) {
                        Method readMethod = sourcePd.getReadMethod();
                        if (readMethod != null) {
                            try {
                                if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
                                    readMethod.setAccessible(true);
                                }
                                Object sourceValue = readMethod.invoke(source);
                                if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
                                    writeMethod.setAccessible(true);
                                }
                                if (sourceValue != null) {
                                    Object targetValue = getTargetValue(targetPd, sourceValue, targetClass);
                                    if (targetValue != null) {
                                        writeMethod.invoke(target, targetValue);
                                    }
                                }
                            } catch (Exception ex) {
                                throw new IllegalStateException(
                                        "Could not copy property '" + targetPd.getName() + "' from source to target", ex);
                            }
                        }
                    }
                }
            }
        }
    
        /**
         * 当源属性类型和目标属性类型不同时,进行一些内置的转换
         */
        @SuppressWarnings("unchecked")
        private static Object getTargetValue(PropertyDescriptor targetPd, Object sourceValue, Class<?> targetClass) throws ParseException {
            Object targetValue = sourceValue;
            Class<?> targetPropertyType = targetPd.getPropertyType();
            Class<?> sourcePropertyType = sourceValue.getClass();
            // 拷贝属性时如果源类型和目标类型不一致,如果是预定义好的可转换的情况,进行内置转换
            if (!targetPropertyType.isAssignableFrom(sourcePropertyType)) {
                // 将日期类型自动转成yyyy-MM-dd HH:mm:ss类型的字符串
                if (Date.class.isAssignableFrom(sourcePropertyType) && String.class.isAssignableFrom(targetPropertyType)) {
                    targetValue = DateFormatUtils.format((Date) sourceValue, getDateFormat(targetPd.getName(), targetClass));
                }
                // 将yyyy-MM-dd HH:mm:ss类型的字符串自动转成日期类型
                else if (String.class.isAssignableFrom(sourcePropertyType) && Date.class.isAssignableFrom(targetPropertyType)) {
                    targetValue = DateUtils.parseDate((String) sourceValue, getDateFormat(targetPd.getName(), targetClass));
                }
                // 将枚举代码转换为枚举类型
                else if (IBaseEnum.class.isAssignableFrom(targetPropertyType)) {
                    targetValue = BaseEnumUtil.getEnumByCode(sourceValue, (Class<? extends IBaseEnum>) targetPropertyType);
                }
                // 将枚举类型转换为枚举代码
                else if (IBaseEnum.class.isAssignableFrom(sourcePropertyType)) {
                    IBaseEnum baseEnum = (IBaseEnum) sourceValue;
                    targetValue = baseEnum.getCode().getClass().isAssignableFrom(targetPropertyType) ? baseEnum.getCode() : baseEnum.getDesc();
                }
                // 目标类型指定为String,而源类型不是String的,调用String.valueOf()方法进行适配转换
                else if (String.class.isAssignableFrom(targetPropertyType)) {
                    targetValue = String.valueOf(sourceValue);
                }
            }
            return targetValue;
        }
    
        private static String getDateFormat(String targetPropertyName, Class<?> targetClass) {
    
            String key = targetClass.getName() + "-" + targetPropertyName;
            return DATE_FORMAT_CACHE.computeIfAbsent(key, o -> {
                DateFormat annotation = null;
                try {
                    Field field = targetClass.getDeclaredField(targetPropertyName);
                    annotation = field.getAnnotation(DateFormat.class);
                } catch (NoSuchFieldException e) {
                    LOGGER.error("no such field", e);
                }
                return Optional.ofNullable(annotation).map(DateFormat::value).orElse(DateUtil.DEFAULT_DATE_FORMAT);
            });
        }
    }
    
    

    **枚举工具类BaseEnumUtil **

    /**
     * 枚举工具类
     */
    public class BaseEnumUtil {
    
        private BaseEnumUtil() {
        }
    
        /**
         * 根据code获取枚举
         *
         * @param code     代码
         * @param enumType 枚举类型对象
         * @param <T>      枚举类型
         * @return 枚举
         */
        public static <T extends IBaseEnum> T getEnumByCode(Object code, Class<T> enumType) {
            if (code != null) {
                for (T t : enumType.getEnumConstants()) {
                    if (StringUtils.equals(String.valueOf(t.getCode()), String.valueOf(code))) {
                        return t;
                    }
                }
            }
            return null;
        }
    
        /**
         * 根据desc获取枚举
         *
         * @param desc     描述
         * @param enumType 枚举类型对象
         * @param <T>      枚举类型
         * @return 枚举
         */
        public static <T extends IBaseEnum> T getEnumByDesc(String desc, Class<T> enumType) {
            if (StringUtils.isNotBlank(desc)) {
                for (T t : enumType.getEnumConstants()) {
                    if (t.getDesc().equals(desc)) {
                        return t;
                    }
                }
            }
            return null;
        }
    
        /**
         * 根据code或者desc获取枚举
         *
         * @param code     代码或者描述
         * @param enumType 枚举类型对象
         * @param <T>      枚举类型
         * @return 枚举
         */
        public static <T extends IBaseEnum> T getEnumByCodeOrDesc(Object code, Class<T> enumType) {
            T result = getEnumByCode(code, enumType);
            if (result == null) {
                result = getEnumByDesc(ObjectUtils.toString(code), enumType);
            }
            return result;
        }
    }
    
    

    @DateFormat注解

    /**
     * 在使用BeanMapUtil进行Bean映射时,如果需要指定日期转换或者格式化的字符串格式,可以使用此注解指定
     * 具体使用方法为在目标类的日期字段或者日期字符串字段上加上此注解,并指定日期格式
     */
    @Target(ElementType.FIELD)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface DateFormat {
    
        /**
         * 指定日期格式
         * @return 日期格式
         */
        String value() default DateUtil.DEFAULT_DATE_FORMAT;
    }
    
    

    IBaseEnum接口

    /**
     * 实现此接口的枚举类型能被Spring MVC接收参数时自动转换
     */
    public interface IBaseEnum<T> extends Serializable {
    
        /**
         * 返回枚举代码
         * @return 枚举代码
         */
        T getCode();
    
        /**
         * 返回枚举描述
         * @return 返回枚举描述
         */
        @JsonValue
        String getDesc();
    }
    
    
    展开全文
  • 本号主要是Java常用关键技术点,通用工具类的分享;以及springboot+springcloud+Mybatisplus+druid+mysql+redis+swagger+maven+docker等集成框架的技术分享;datax、kafka、flink等大数据处理框架的技术分享。文章会...

    介绍语

    本号主要是Java常用关键技术点,通用工具类的分享;以及springboot+springcloud+Mybatisplus+druid+mysql+redis+swagger+maven+docker等集成框架的技术分享;datax、kafka、flink等大数据处理框架的技术分享。文章会不断更新,欢迎码友关注点赞收藏转发!

    望各位码友点击关注,冲1000粉。后面会录制一些视频教程,图文和视频结合,比如:图书介绍网站系统、抢购系统、大数据中台系统等。技术才是程序猿的最爱,码友们冲啊

    如果码友觉得代码太长,可以从头到尾快速扫射一遍,了解大概即可。觉得有用后再转发收藏,以备不时之需。

    正文:

    对象复制工具类,简单好用。但是使用场景好像不多,先收藏

    例子1

    复制学生类到另一个学生类

    import java.time.LocalDate;
     ​
     public class BeanUtilTest {
         public static void main(String[] args) {
             Student student = new Student("zhang三",
                     12, "花果山", LocalDate.of(1990, 2, 26));
             Student studentCopy = new Student();
             BeanCopyUtil.merge(student, studentCopy);
     ​
             System.out.println(studentCopy);
         }
     }
     ​
     // 控制台打印
     Student(name=zhang三, age=12, address=花果山, birthday=1990-02-26)

    例子用到的实体类

    import lombok.AllArgsConstructor;
     import lombok.Data;
     import lombok.NoArgsConstructor;
     ​
     import java.time.LocalDate;
     ​
     @Data
     @AllArgsConstructor
     @NoArgsConstructor
     public class Student {
         private String name;
         private int age;
         private String address;
         private LocalDate birthday;
     }

    工具类源码:

    import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     ​
     import java.lang.reflect.Field;
     ​
     /**
      * 对象赋值工具类
      *
      * @author liangxn
      */
     public class BeanCopyUtil {
     ​
         private static final Logger logger = LoggerFactory.getLogger(BeanCopyUtil.class);
     ​
         /**
          * 相同对象合并,将原对象的非空属性的值赋值给目标对象
          *
          * @param origin      源对象
          * @param destination 目标对象
          * @param <T>         对象的类型
          */
         public static <T> void merge(T origin, T destination) {
             if (origin == null || destination == null) {
                 return;
             }
             if (!origin.getClass().equals(destination.getClass())) {
                 return;
             }
     ​
             Field[] fields = origin.getClass().getDeclaredFields();
             for (Field field : fields) {
                 field.setAccessible(true);
                 try {
                     Object value = field.get(origin);
                     if (null != value) {
                         field.set(destination, value);
                     }
                 } catch (IllegalAccessException e) {
                     logger.error("访问对象异常", e);
                 }
                 field.setAccessible(false);
             }
         }
     }

    鄙人编码十年多,在项目中也积累了一些工具类,很多工具类在每个项目都有在用,很实用。大部分是鄙人封装的,有些工具类是同事封装的,有些工具类已经不记得是ctrl+c的还是自己封装的了,现在有空就会总结项目中大部分的工具类,分享给各位码友。如果文章中涉及的代码有侵权行为请通知鄙人处理。

    计划是先把工具类整理出来,正所谓工欲善其事,必先利其器。项目中不管是普通单体项目还是多模块maven项目或是分布式微服务,一部分功能模块都是可以重用的,工具类模块就是其中之一。

    展开全文
  • 好工具推荐——Hutool工具类

    千次阅读 2020-12-29 11:22:55
    1、简介 Hutool是一个小而全的Java工具类库,通过...Hutool是项目中“util”包友好的替代,它节省了开发人员对项目中公用和公用工具方法的封装时间,使开发专注于业务,同时可以最大限度的避免封装不完善带来的bug。

    1、简介

    Hutool是一个小而全的Java工具类库,通过静态方法封装,降低相关API的学习成本,提高工作效率,使Java拥有函数式语言般的优雅,让Java语言也可以“甜甜的”。

    Hutool中的工具方法来自每个用户的精雕细琢,它涵盖了Java开发底层代码中的方方面面,它既是大型项目开发中解决小问题的利器,也是小型项目中的效率担当;

    Hutool是项目中“util”包友好的替代,它节省了开发人员对项目中公用类和公用工具方法的封装时间,使开发专注于业务,同时可以最大限度的避免封装不完善带来的bug。

    2、Hutool名称的由来

    Hutool = Hu + tool,是原公司项目底层代码剥离后的开源库,“Hu”是公司名称的表示,tool表示工具。Hutool谐音“糊涂”,一方面简洁易懂,一方面寓意“难得糊涂”。

    3、Hutool如何改变我们的coding方式

    Hutool的目标是使用一个工具方法代替一段复杂代码,从而最大限度的避免“复制粘贴”代码的问题,彻底改变我们写代码的方式。

    以计算MD5为例:

    • 【以前】打开搜索引擎 -> 搜“Java MD5加密” -> 打开某篇博客-> 复制粘贴 -> 改改好用
    • 【现在】引入Hutool -> SecureUtil.md5()

    Hutool的存在就是为了减少代码搜索成本,避免网络上参差不齐的代码出现导致的bug。


    4、包含组件

    一个Java基础工具类,对文件、流、加密解密、转码、正则、线程、XML等JDK方法进行封装,组成各种Util工具类,同时提供以下组件:

    模块介绍
    hutool-aopJDK动态代理封装,提供非IOC下的切面支持
    hutool-bloomFilter布隆过滤,提供一些Hash算法的布隆过滤
    hutool-cache简单缓存实现
    hutool-core核心,包括Bean操作、日期、各种Util等
    hutool-cron定时任务模块,提供类Crontab表达式的定时任务
    hutool-crypto加密解密模块,提供对称、非对称和摘要算法封装
    hutool-dbJDBC封装后的数据操作,基于ActiveRecord思想
    hutool-dfa基于DFA模型的多关键字查找
    hutool-extra扩展模块,对第三方封装(模板引擎、邮件、Servlet、二维码、Emoji、FTP、分词等)
    hutool-http基于HttpUrlConnection的Http客户端封装
    hutool-log自动识别日志实现的日志门面
    hutool-script脚本执行封装,例如Javascript
    hutool-setting功能更强大的Setting配置文件和Properties封装
    hutool-system系统参数调用封装(JVM信息等)
    hutool-jsonJSON实现
    hutool-captcha图片验证码实现
    hutool-poi针对POI中Excel和Word的封装
    hutool-socket基于Java的NIO和AIO的Socket封装

    可以根据需求对每个模块单独引入,也可以通过引入hutool-all方式引入所有模块。

     在项目的pom.xml的dependencies中加入以下内容:

            <dependency>
    			<groupId>cn.hutool</groupId>
    			<artifactId>hutool-all</artifactId>
    			<version>5.4.1</version>
    		</dependency>

    5、补充

    这不只列举了一部分的工具类,简单看了一下,功能真的很强大。个人很喜欢用Convert类和DateUtil,有网络的情况下,建议先配置maven的中心仓库,然后下载源码+注释(这点是我很喜欢的,注释特别详细),然后再切回私库,不影响正常使用还能看到特别详细的注释,如下图:

     

     话不多少,官网推荐:https://www.hutool.cn/

     

     

     

    展开全文
  • 数学运算工具(精确运算)/**** @author maple**/public abstract class AmountUtil {private AmountUtil() {}/*** 加法运算** @param v1* @param v2* @return*/public static double add(double v1, double v2) {...
  • Java工具类

    2021-02-27 08:52:05
    Class对象自动被创建 常用方法 方法 作用 Class forName(String name) 返回一个名name的Class对象 class getClass() 返回一个Class对象 String getName() 返回调用对象的或者接口的全名 class getSuperclass()...
  • 异步调用工具类

    2021-03-14 11:08:42
    原理异步工具类就是在系统启动时候先初始化一个符合参数自己工作环境的线程池,所有的异步操作占用的线程都是从这个线程池中获取的,这样能进行资源统一管理,不会因为异步操作而占用过多的服务器资源。实现异步工具...
  • } } 2.4 简单总结 使用该工具类需要注意以下几点: 按需重写集合中实体的equal()、hashCode()两个方法 按需定义CompareSelection。如果没有定义则默认计算三种类型。 3.工具类简单测试 package cn.sun.test.utils; ...
  • JAVA树形结构工具类

    2021-03-15 17:53:46
    BaseTreeObj.java/*** 基层树形结构实体* 必备属性:id,parentId,childsList*/@Datapublic class BaseTreeObj implements Serializable {private static final long serialVersionUID = 1L;private String id;...
  • java线程池工具类

    千次阅读 2021-02-27 13:55:21
    import java.util.concurrent.ExecutorService;import java.util.concurrent..../*** 线程池基础*/public class ThreadPoolUtil {/*** 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有...
  • 上一篇blog中将工具类写成了静态类(所有的方法都是静态方法),今天发现了这种方式的弊端。且听我慢慢道来:今天需要重构一个实习生的代码,逻辑很简单,消费kafka,提取需要的内容写入ssdb,他将配置信息直接写到了...
  • Springboot Mybatis Plus代码自动生成工具类

    万次阅读 多人点赞 2021-11-23 14:21:56
    文章目录前言一、pom依赖二、工具类结尾 前言 代码生成器,也叫逆向工程,是根据数据库里的表结构,自动生成对应的实体类、映射文件和接口。 看到很多小伙伴在为数据库生成实体类发愁,现分享给大家,提高开发效率...
  • Java防SQL注入工具类

    2021-02-28 09:15:05
    import javax.servlet..../*** 防SQL注入工具类* 把SQL关键字替换为空字符串* @author zhao* @since 2015.7.23*/public class AntiSqlInjection {public final static String regex = "'|%|--|and|or|not|use|in...
  • Java占位符替换工具类

    2021-03-13 05:49:13
    import java.util.HashMap;import java.util.Map;import org.slf4j.Logger;.../*** 配置文件或模板中的占位符替换工具类* Date: 15-5-8* Time: 下午4:12*/public class PlaceholderUtils {private static f...
  • 轻松解析XML的工具类

    千次阅读 2021-03-06 17:45:22
    /*** * 解析xml的 * @author qindongliang * * * **/ public class ParseXML { public static void main(String[] args) throws Exception{ loadxml(); } public static void loadxml() throws Exception{ XML...
  • java雪花算法工具类

    万次阅读 2021-06-04 09:58:13
    创建一个SnowFlake的工具类,然后把下面的代码粘过去就可以了 /** * Twitter_Snowflake<br> * SnowFlake的结构如下(每部分用-分开):<br> * 0 - 0000000000 0000000000 0000000000 0000000000 0 - ...
  • java常用空判断工具类

    2021-02-12 17:39:48
    } /** *======================================== * * @方法说明 : 空判断 所有值为空返回true * @author : miss you BUG * @param t bean * @return boolean * @exception * @创建时间: 2020/7/9 14:14 *===...
  • 参数校验工具类:封装在一个公有方法里面 应用案例: 完整的java类信息: 前言: 经常要遇到判断各种是否为空的情况,String有lang3的StringUtils,CollectionUtils。为啥子不能直接的放进一个工具类处理呢?...
  • 常用工具类之JsonUtils

    2021-03-18 11:59:16
    } } 相关文章 总结 以上是编程之家为你收集整理的常用工具类之JsonUtils全部内容,希望文章能够帮你解决常用工具类之JsonUtils所遇到的程序开发问题。 如果觉得编程之家网站内容还不错,欢迎将编程之家网站推荐给...
  • 在工作中经常会遇到操作excel的需求,对于格式简单、统一的excel可以选择EasyExcel来实现功能,很简单方便;而对于复杂的excel文件,如有...这里贴上在工作中解决问题时,自己封装的工具类,方便大家查阅: ...
  • java 打包工具jar,打包工具类为jar包,注意事项
  • 【Java工具类】之Bean转换

    千次阅读 2021-08-01 11:37:40
    由于需要在各个bean直接进行copy数据,除了傻瓜式的set/get or constructor来copy数据外,spring提供了直接copybean的工具类,原理其实就是通过java反射来根据目标bean的字段名调用其set方法来设值注入。除此之外,...
  • package ...import org.springframework.beans.factory.config.YamlPropertiesFactoryBean;import org.springframework.core.io.ClassPathResource;import org.springframework.core.io.Resource...
  • Java PDF工具类(一)| 使用 itextpdf 根据设置好的PDF模板填充PDF(文字和图片)相关文章: Java PDF工具类(二)| 使用 wkhtmltox 实现 HTML转PDF(文字/图片/页眉页脚).参考文章:...
  • 1.1工具类代码 public static SimpleDateFormat sdfTest = new SimpleDateFormat("yyyy年MM月dd日"); public static Date selectDate(String stageDuring) { try { System.out.println(Thread.currentThread...
  • /** * @author jfp * @create 2020/11/19 15:04 * @desc BeanCopy工具 **/ public class BeanCopyUtils { private BeanCopyUtils(){ // 防止实例化工具类 throw new AssertionError("No " + BeanCopyUtils.class....
  • apache工具包common-lang中有一个很有用的处理字符串的工具类,其中之一就是StringEscapeUtils,这个工具类是在2.3版本以上加上的去的,利用它能很方便的进行html,xml,java等的转义与反转义,而且还能对关键字符串...
  • java SM2加密工具类(测试可用)

    千次阅读 2021-01-20 13:51:59
    maven依赖 <dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcprov-jdk15on</artifactId>...SM2Util工具类 import java.math.BigInteger; import java.s
  • Utility工具类

    2021-02-21 09:50:39
    开发中我们时常会将一些经常用到的工具方法提取出来,放到一个XXUtility中,方便以后使用。 下面以限制Transform自身角度为例: 1.首先我们编写一个静态的MathUtility: public static class MathUtility{} ...
  • Java Hutool(糊涂)工具类索引记录

    千次阅读 2021-05-17 08:48:44
    有时候工具类太多,包括项目封装的,不知道用哪一个,在这里记录下目录,方便查找 介绍 Hutool 是一个 Java 工具包,也只是一个工具包,它帮助我们简化每一行代码,减少每一个方法,让 Java 语言也可以“甜甜的”。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,605,093
精华内容 1,042,037
关键字:

装机工具