精华内容
下载资源
问答
  • java工具类开发之json工具类JsonUtils和数据回页面工具类ResponseUtils  采用Java开发应用软件,如果数据库层采用蛋疼的纯生jdbc时候,需要考虑到将查询数据库得到的结果集resultRest进行转换为JsonArray并将...

    java工具类开发之json工具类JsonUtils和写数据回页面工具类ResponseUtils

         采用Java开发应用软件,如果数据库层采用蛋疼的纯生jdbc时候,需要考虑到将查询数据库得到的结果集resultRest进行转换为JsonArray并将其返回到页面!当然了,现在对于“将查询数据库得到的结果集resultRest转换为JsonArray”已经有很多json的库来解决了,譬如json-lib、gson、jackson、fastjson等等,本文介绍的正是json-lib这种比较纯洁的库来处理resultSet,晚点再介绍jackson 和 fastjson。对于“将后台处理后的结果返回到页面”,我们需要自己封装一个:可用于ajax异步调用的!

         首先介绍一下JsonUtils,对于JsonUtils,因为我们是用来处理resultSet的,所以,我们首先需要有一个DBConnUtils来获取数据库链接,以便后面我们查询数据库得到ResultSet,最终用于测试。首先我需要加入c3p0的jar包和mysql的驱动jar包,因为我们用到的就是采用c3p0来获取数据库链接并进行相关的数据库操作的!

         当然啦,除此之外,我们需要加入json-lib的jar包:要注意加全!!!!不然会出现很多蛋疼的问题!!可以来这里下载本文涉及到的工具类开发的时候需要的jar包: jar包下载

        下面是截图:其中 db.properties是一个属性属性文件,其内容可以在前一篇博文看到!  右边是数据库表tb_user表中的内容,下面会用到!!

                                              

         

         下面是DBConnUtils工具类的内容:

    <span style="font-size:18px;">package com.steadyjack.utils;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    
    /**
     * @author 钟林森
     * 获取数据库链接工具类
     */
    public class DBConnUtils {
    	
        private static String driver=null;
        private static String url=null;  
        private static String user=null;
        private static String password=null;  
        //采用读取属性配置文件工具类PropertiesUtils.java读取相关属性值
        static{
        	driver=PropertiesUtils.readProperty("driver");
        	url=PropertiesUtils.readProperty("url");
        	user=PropertiesUtils.readProperty("user");
        	password=PropertiesUtils.readProperty("password");
        }
        
    	public static Connection getConn(){  
            //加载驱动程序  
            try {  
                Class.forName(driver);  
            } catch (ClassNotFoundException e) {  
                e.printStackTrace();  
            }  
              
            //链接数据库  
            Connection conn=null;  
            try {  
                conn=DriverManager.getConnection(url, user, password);  
                if (!conn.isClosed()) {  
                    System.out.println("连接数据库成功");  
                }  
            } catch (SQLException e) {  
                System.out.println("链接数据库失败: "+e.getMessage());  
            }  
              
            return conn;  
        }  
    }
    </span>

           下面是JsonUtils的代码,具体我就不多解释,我在代码已经解释的很清楚了(其实:得到的ResultSet就是一个二维表或者说是矩阵,本质是采用行列先后访问:先遍历行,再遍历每一行对应的每一列的名称和数据!)

    package com.steadyjack.utils;
    
    import java.sql.ResultSet;
    import java.sql.ResultSetMetaData;
    import java.util.Date;
    
    import net.sf.json.JSONArray;
    import net.sf.json.JSONObject;
    
    /**
     * @author 钟林森
     * 用于处理查询得到的ResultSet转变为JsonArray
     */
    public class JsonUtils {
    	
    	/**
    	 * 将查询数据库得到的结果集转化为JsonArray,供前端使用
    	 * @author 钟林森
    	 * @param rs 查询数据库得到的结果集:其实就一个矩阵(二维表)
    	 * @return 
    	 * @throws Exception
    	 * 
    	 * 简单的理解:"先遍历行,对于每一行获取每一列的列名以及改行该列对于的值" ,所以需要获取有多少列,以及每一列的列名(元数据ResultSetMetaData)
    	 */
    	public static JSONArray formatRsToJsonArray(ResultSet rs) throws Exception{
    		//先获取元数据操作对象:ResultSetMetaData 以及  一共有多少列
    		ResultSetMetaData rsmd=rs.getMetaData();
    		int columnCount=rsmd.getColumnCount();
    		
    		//jsonArray存放的是每个jsonObject:其实就是resultSet的一行数据
    		JSONArray jsonArray=new JSONArray();
    		
    		//开始遍历每一行
    		while(rs.next()){
    			JSONObject mapOfColValue=new JSONObject();
    			for(int i=1;i<=columnCount;i++){
    				Object object=rs.getObject(i);
    				
    				//由于数据库表字段可能含有日期date,所以需要进行特殊处理
    				if (object instanceof Date) {
    					mapOfColValue.put(rsmd.getColumnName(i), DateUtils.dateToStr((Date)object, "yyyy-MM-dd"));
    				}else{
    					mapOfColValue.put(rsmd.getColumnName(i), object);
    				}
    			}
    			
    			//遍历获取完一条数据就添加到jsonArray中
    			jsonArray.add(mapOfColValue);
    		}
    		
    		return jsonArray;
    	}
    	
    }

          这篇博文我觉得它写得比较详细: json学习-JSONArray的应用,我参考了一下;下面是JsonUtils和DBConnUtils的单元测试类:

    package com.steadyjack.testUtils;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    
    import net.sf.json.JSONArray;
    
    import org.junit.Test;
    
    import com.steadyjack.utils.DBConnUtils;
    import com.steadyjack.utils.JsonUtils;
    
    /**
     * @author 钟林森
     * 
     */
    public class JsonUtilsTest {
    	
    	@Test
    	public void test() throws Exception{
    		
    		Connection connection=DBConnUtils.getConn();
    		System.out.println(connection);
    		
    		String sql="SELECT id,name,address,last_name FROM tb_user";
    		PreparedStatement pstmt=connection.prepareCall(sql);
    		ResultSet rs=pstmt.executeQuery();
    		
    		JSONArray jsonArray=JsonUtils.formatRsToJsonArray(rs);
    		
    		//JsonArray 转换为数组
    		Object[] obj=JSONArray.fromObject(jsonArray.toString()).toArray();  
    		for(int i=0;i<obj.length;i++){  
    			System.out.println(obj[i]);  
    		}	  
    		System.out.println();
    		
    	}
    	
    }
    
    

         得到的结果如下截图:



          最后,介绍一个ResponseUtils工具类,用于将后台处理相关业务逻辑后得到的最终结果返回到前端,这个前端可以使页面,也可以js异步调用的结果!这个的话,就没写js调用进行测试!!

    package com.steadyjack.utils;
    
    import java.io.PrintWriter;
    import javax.servlet.http.HttpServletResponse;
    
    /**
     * 将后台处理完的结果写回前端页面,如jsp页面;
     * 或者可用于在ajax异步调用后台方法,该方法处理完相应业务逻辑之后将结果返回,这个结果即通过这个工具类实现
     * @author 钟林森
     */
    public class ResponseUtil {
    
    	public static void write(HttpServletResponse response,Object o)throws Exception{
    		response.setContentType("text/html;charset=utf-8");
    		PrintWriter out=response.getWriter();
    		out.println(o.toString());
    		out.flush();
    		out.close();
    	}
    }
    

              本文就介绍到这里了!!!

    展开全文
  • RestTemplateUtils工具类

    千次阅读 2019-06-10 09:54:55
    RestTemplateUtils 工具类 最强RestTemplateUtils 可绕过https请求,带异常处理,容错机制,以及设置链接时间.设置读写时间。 工具类 import com.alibaba.fastjson.JSONObject; import org.springframework....
    					spring RestTemplateUtils 工具类
    

    spring 中 RestTemplateUtils使用方法

    V2.0 版本(优化部分代码)
    可绕过https请求,带异常处理,容错机制,以及设置链接时间.设置读写时间。

    工具类可以 http请求 https 请求
    支持 post,get,加密,请求方式

    工具类

    
    import com.alibaba.fastjson.JSONObject;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.http.HttpEntity;
    import org.springframework.http.HttpHeaders;
    import org.springframework.http.client.ClientHttpResponse;
    import org.springframework.http.client.SimpleClientHttpRequestFactory;
    import org.springframework.http.converter.StringHttpMessageConverter;
    import org.springframework.util.MultiValueMap;
    import org.springframework.web.client.ResponseErrorHandler;
    import org.springframework.web.client.RestClientException;
    import org.springframework.web.client.RestTemplate;
    
    import javax.servlet.http.HttpServletResponse;
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.nio.charset.StandardCharsets;
    import java.util.Map;
    
    /**
     * restTemplateUtils 高性能请求http https
     *       时间单位 毫秒
     */
    @Slf4j
    public class RestTemplateUtils {
    
    
        // 默认时间五秒,不重试。
        private final static int CONNEC_TIMEOUT = 5000;
        private final static int READ_TIMEOUT   = 5000;
        private final static int RETRY_COUNT    = 1;
    
    
        /**
         * https 请求 GET
         * @param url           地址
         * @param connecTimeout 连接时间  毫秒
         * @param readTimeout   读取时间  毫秒
         * @param retryCount    重试机制
         * @return String 类型
         */
        public static String getHttp(String url, int connecTimeout, int readTimeout, int retryCount) {
            RestTemplate restTemplate = simpeClient(url, connecTimeout, readTimeout);
            String result = null; // 返回值类型;
            for (int i = 1; i <= retryCount; i++) {
                try {
                    result = restTemplate.getForObject(url, String.class);
                    return result;
                } catch (RestClientException e) {
                    log.error("-----------开始-----------重试count: " + i);
                    e.printStackTrace();
                }
            }
            return null;
        }
    
        /**
         * https 请求 GET
         * @param url           地址
         * @return String 类型
         */
        public static String getHttp(String url) {
            RestTemplate restTemplate = simpeClient(url, CONNEC_TIMEOUT, READ_TIMEOUT);
            String result = null; // 返回值类型;
            for (int i = 1; i <= RETRY_COUNT; i++) {
                try {
                    result = restTemplate.getForObject(url, String.class);
                    return result;
                } catch (RestClientException e) {
                    log.error("-----------开始-----------重试count: " + i);
                    e.printStackTrace();
                }
            }
            return null;
        }
    
    
        /**
         * http 请求 post
         * @param url           地址
         * @param params        参数
         * @param headersMap    header
         * @param connecTimeout 连接时间
         * @param readTimeout   读取时间`
         * @param retryCount    重试机制
         * @return String 类型
         */
        public static String postHttp(String url, JSONObject params, Map headersMap, int connecTimeout, int readTimeout, int retryCount) {
            RestTemplate restTemplate =  simpeClient(url, connecTimeout, readTimeout);
            // 设置·header信息
            HttpHeaders requestHeaders = new HttpHeaders();
            requestHeaders.setAll(headersMap);
            HttpEntity<JSONObject> requestEntity = new HttpEntity<JSONObject>(params, requestHeaders); // josn utf-8 格式
            String result = null; // 返回值类型;
            for (int i = 1; i <= retryCount; i++) {
                try {
                    result = restTemplate.postForObject(url, requestEntity, String.class);
                    return result;
                } catch (RestClientException e) {
                    log.error("-----------开始-----------重试count: " + i);
                    e.printStackTrace();
                }
            }
            return null;
        }
    
    
        /**
         * http 请求 post
         * @param url           地址
         * @param params        参数
         * @param headersMap    header
         * @return String 类型
         */
        public static String postHttp(String url, JSONObject params, Map headersMap) {
            RestTemplate restTemplate = simpeClient(url, CONNEC_TIMEOUT, READ_TIMEOUT);
            // 设置·header信息
            HttpHeaders requestHeaders = new HttpHeaders();
            requestHeaders.setAll(headersMap);
            HttpEntity<JSONObject> requestEntity = new HttpEntity<JSONObject>(params, requestHeaders); // josn utf-8 格式
            String result = null; // 返回值类型;
            for (int i = 1; i <= RETRY_COUNT; i++) {
                try {
                    result = restTemplate.postForObject(url, requestEntity, String.class);
                    return result;
                } catch (RestClientException e) {
                    log.error("-----------开始-----------重试count: " + i);
                    e.printStackTrace();
                }
            }
            return null;
        }
    
    
        /**
         * 加密参数类型请求  application/x-www-form-urlencoded
         * MultiValueMap<String, Object>
         * 采用 HttpEntity<MultiValueMap<String, Object>> 构造
         * http 请求 post
         *
         * @param url           地址
         * @param postParameters 参数
         * @param headersMap    header
         * @param connecTimeout 连接时间
         * @param readTimeout   读取时间
         * @param retryCount    重试机制
         * @return String 类型
         */
        public static String postHttpEncryption(String url, MultiValueMap<String, Object> postParameters, Map headersMap, int connecTimeout, int readTimeout, int retryCount) {
            RestTemplate restTemplate = simpeClient(url, connecTimeout, readTimeout);
            // 设置·header信息
            HttpHeaders requestHeaders = new HttpHeaders();
            requestHeaders.setAll(headersMap);
            HttpEntity<MultiValueMap<String, Object>> requestEntity = new HttpEntity<>(postParameters, requestHeaders);
            String result = null; // 返回值类型;
            for (int i = 1; i <= retryCount; i++) {
                try {
                    result = restTemplate.postForObject(url, requestEntity, String.class);
                    return result;
                } catch (RestClientException e) {
                    log.error("-----------开始-----------重试count: " + i);
                    e.printStackTrace();
                }
            }
            return null;
        }
    
        /**
         * 加密参数类型请求  application/x-www-form-urlencoded
         * MultiValueMap<String, Object>
         * 采用 HttpEntity<MultiValueMap<String, Object>> 构造
         * http 请求 post
         * @param url           地址
         * @param postParameters 参数
         * @param headersMap    header
         * @return String 类型
         */
        public static String postHttpEncryption(String url, MultiValueMap<String, Object> postParameters, Map headersMap) {
            RestTemplate restTemplate = simpeClient(url, CONNEC_TIMEOUT, READ_TIMEOUT);
            // 设置·header信息
            HttpHeaders requestHeaders = new HttpHeaders();
            requestHeaders.setAll(headersMap);
            HttpEntity<MultiValueMap<String, Object>> requestEntity = new HttpEntity<>(postParameters, requestHeaders);
            String result = null; // 返回值类型;
            for (int i = 1; i <= RETRY_COUNT; i++) {
                try {
                    result = restTemplate.postForObject(url, requestEntity, String.class);
                    return result;
                } catch (RestClientException e) {
                    log.error("-----------开始-----------重试count: " + i);
                    e.printStackTrace();
                }
            }
            return null;
        }
    
    
    
    
    
        private static RestTemplate simpeClient(String url, int connecTimeout, int readTimeout) {
            SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
            requestFactory.setConnectTimeout(connecTimeout);
            requestFactory.setReadTimeout(readTimeout);
            RestTemplate restTemplate = new RestTemplate(requestFactory);
            restTemplate.getMessageConverters().set(1, new StringHttpMessageConverter(StandardCharsets.UTF_8)); // 设置编码集
            restTemplate.setErrorHandler(new DefaultResponseErrorHandler()); //error处理
            if (url.contains("https")){
                restTemplate.setRequestFactory(new HttpsClientRequestFactory()); // 绕过https
            }
            return restTemplate;
        }
    
    
        /**
         * @ClassName: DefaultResponseErrorHandler
         * @Description: TODO
         * @author:
         * @date: 2
         */
        private static class DefaultResponseErrorHandler implements ResponseErrorHandler {
    
            /**
             * 对response进行判断,如果是异常情况,返回true
             */
            @Override
            public boolean hasError(ClientHttpResponse response) throws IOException {
                return response.getStatusCode().value() != HttpServletResponse.SC_OK;
            }
    
            /**
             * 异常情况时的处理方法
             */
            @Override
            public void handleError(ClientHttpResponse response) throws IOException {
                BufferedReader br = new BufferedReader(new InputStreamReader(response.getBody()));
                StringBuilder sb = new StringBuilder();
                String str = null;
                while ((str = br.readLine()) != null) {
                    sb.append(str);
                }
                try {
                    throw new Exception(sb.toString());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    
    

    https 绕过工具类

    
    
    import org.springframework.http.client.SimpleClientHttpRequestFactory;
    
    import javax.net.ssl.*;
    import java.io.IOException;
    import java.net.HttpURLConnection;
    import java.net.InetAddress;
    import java.net.Socket;
    import java.security.cert.X509Certificate;
    
    /**
     * Https 绕过
     */
    public class HttpsClientRequestFactory extends SimpleClientHttpRequestFactory {
    
    
        @Override
        protected void prepareConnection(HttpURLConnection connection, String httpMethod) {
            try {
                if (!(connection instanceof HttpsURLConnection)) {
                    throw new RuntimeException("An instance of HttpsURLConnection is expected");
                }
    
                HttpsURLConnection httpsConnection = (HttpsURLConnection) connection;
    
                TrustManager[] trustAllCerts = new TrustManager[]{
                        new X509TrustManager() {
                            @Override
                            public X509Certificate[] getAcceptedIssuers() {
                                return null;
                            }
                            @Override
                            public void checkClientTrusted(X509Certificate[] certs, String authType) {
                            }
                            @Override
                            public void checkServerTrusted(X509Certificate[] certs, String authType) {
                            }
    
                        }
                };
                SSLContext sslContext = SSLContext.getInstance("TLS");
                sslContext.init(null, trustAllCerts, new java.security.SecureRandom());
                httpsConnection.setSSLSocketFactory(new MyCustomSSLSocketFactory(sslContext.getSocketFactory()));
    
                httpsConnection.setHostnameVerifier(new HostnameVerifier() {
                    @Override
                    public boolean verify(String s, SSLSession sslSession) {
                        return true;
                    }
                });
    
                super.prepareConnection(httpsConnection, httpMethod);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        /**
         * We need to invoke sslSocket.setEnabledProtocols(new String[] {"SSLv3"});
         * see http://www.oracle.com/technetwork/java/javase/documentation/cve-2014-3566-2342133.html (Java 8 section)
         */
        // SSLSocketFactory用于创建 SSLSockets
        private static class MyCustomSSLSocketFactory extends SSLSocketFactory {
    
            private final SSLSocketFactory delegate;
    
            public MyCustomSSLSocketFactory(SSLSocketFactory delegate) {
                this.delegate = delegate;
            }
    
            // 返回默认启用的密码套件。除非一个列表启用,对SSL连接的握手会使用这些密码套件。
            // 这些默认的服务的最低质量要求保密保护和服务器身份验证
            @Override
            public String[] getDefaultCipherSuites() {
                return delegate.getDefaultCipherSuites();
            }
    
            // 返回的密码套件可用于SSL连接启用的名字
            @Override
            public String[] getSupportedCipherSuites() {
                return delegate.getSupportedCipherSuites();
            }
    
    
            @Override
            public Socket createSocket(final Socket socket, final String host, final int port,
                                       final boolean autoClose) throws IOException {
                final Socket underlyingSocket = delegate.createSocket(socket, host, port, autoClose);
                return overrideProtocol(underlyingSocket);
            }
    
    
            @Override
            public Socket createSocket(final String host, final int port) throws IOException {
                final Socket underlyingSocket = delegate.createSocket(host, port);
                return overrideProtocol(underlyingSocket);
            }
    
            @Override
            public Socket createSocket(final String host, final int port, final InetAddress localAddress,
                                       final int localPort) throws
                    IOException {
                final Socket underlyingSocket = delegate.createSocket(host, port, localAddress, localPort);
                return overrideProtocol(underlyingSocket);
            }
    
            @Override
            public Socket createSocket(final InetAddress host, final int port) throws IOException {
                final Socket underlyingSocket = delegate.createSocket(host, port);
                return overrideProtocol(underlyingSocket);
            }
    
            @Override
            public Socket createSocket(final InetAddress host, final int port, final InetAddress localAddress,
                                       final int localPort) throws
                    IOException {
                final Socket underlyingSocket = delegate.createSocket(host, port, localAddress, localPort);
                return overrideProtocol(underlyingSocket);
            }
    
            private Socket overrideProtocol(final Socket socket) {
                if (!(socket instanceof SSLSocket)) {
                    throw new RuntimeException("An instance of SSLSocket is expected");
                }
                ((SSLSocket) socket).setEnabledProtocols(new String[]{"TLSv1"});
                return socket;
            }
        }
    
    
    }
    
    

    如果合适你的项目,请点赞哦!

    展开全文
  • Json寻址工具类

    万次阅读 2020-04-15 17:05:52
    抽空了个根据地址寻址json内容中的某个值的工具类。 说明: 1.工具类使用google Gson,有兴趣的可以使用其他json序列号工具改造。大概流程都一样 private static final String JSON_ARRAY_FORMAT...

    在项目使用中,经常使用json的反序列化获取某个值,如果某个值的路径比较深,除了编写工作量变大和风险扩大外,还有就是代码不够整洁。抽空写了个根据地址寻址json内容中的某个值的工具类。

    说明:

    1.工具类使用google Gson,有兴趣的可以使用其他json序列号工具改造。大概流程都一样

         private static final String JSON_ARRAY_FORMAT = "(.)*(\\[(\\d)+])$";
    
     /**
         * 根据路径获取json对象的值
         * 约定:
         * 路径格式:下层用点代表 数组用[index]代表
         * 举例:
         * a.b[1].c
         * [0].a.c
         * a[1].b
         * a.
         * [0]
         *
         * @param json
         * @param path
         * @return Object 如果获取不到 返回null
         */
        public static <T> T getObjectGson4Path(String json, String path, Class<T> tClass) {
            Gson gson = new Gson();
            JsonElement value4Path = getValue4Path(json, path);
            if (null == value4Path) {
                LOGGER.error("can't find value by path {} ", path);
                return null;
            }
            try {
                return gson.fromJson(value4Path, tClass);
            } catch (JsonSyntaxException e) {
                LOGGER.error("can't find format Type is {} value", tClass.getName());
                return null;
            }
        }
    
        /**
         * 根据路径获取json对象的值
         * 约定:
         * 路径格式:下层用点代表 数组用[index]代表
         * 举例:
         * a.b[1].c
         * [0].a.c
         * a[1].b
         * a.
         * [0]
         *
         * @param json
         * @param path
         * @return List 如果获取不到 返回null
         */
        public static <T> List<T> getListGson4Path(String json, String path, Class<T> tClass) {
            Gson gson = new Gson();
            JsonElement value4Path = getValue4Path(json, path);
            if (null == value4Path) {
                LOGGER.error("can't find value by path {} ", path);
                return null;
            }
            if (!value4Path.isJsonArray()) {
                throw new IllegalArgumentException("parse format not match");
            }
            JsonArray asJsonArray = value4Path.getAsJsonArray();
            ArrayList<T> objects = new ArrayList<>(asJsonArray.size());
            try {
                for (JsonElement jsonElement : asJsonArray) {
                    objects.add(gson.fromJson(value4Path, tClass));
                }
            } catch (JsonSyntaxException e) {
                LOGGER.error("can't find format Type is {} value", tClass.getName());
                return null;
            }
            return objects;
        }
    
    
        private static JsonElement getValue4Path(String content, String path) {
            LOGGER.info("content={},path={}", content, path);
            if (StringUtils.isBlank(path)) {
                LOGGER.warn("path is blank");
                return null;
            }
            if (!isJSONStr(content)) {
                LOGGER.warn("content format not json");
                return null;
            }
            JsonParser parser = new JsonParser();
            JsonElement parse = parser.parse(content);
            String[] split = path.split("\\.");
            StringBuilder stringBuilder = new StringBuilder();
            for (String s : split) {
                try {
                    parse = parseJson(parse, s, stringBuilder);
                } catch (Exception e) {
                    LOGGER.warn("can't find value ,this path is {}", path);
                    return null;
                }
            }
            return parse;
        }
    
        private static JsonElement parseJson(JsonElement jsonElement, String childPath, StringBuilder sb) {
            if (jsonElement.isJsonNull()) {
                return null;
            }
            if (StringUtils.isBlank(childPath)) {
                return jsonElement;
            }
            sb.append(".").append(childPath);
            Matcher matcher = Pattern.compile(JSON_ARRAY_FORMAT).matcher(childPath);
            if (matcher.find()) {
                String group = matcher.group(1);
                if (null == group) {
                    group = matcher.group(0);
                }
                String s = group.replaceAll("\\[", "\\\\[");
                String[] split1 = childPath.split(s);
                String key = null;
                if (null == split1 || split1.length == 0) {
                    key = "";
                } else {
                    key = split1[0];
                }
                String index = group.substring(1, group.length() - 1);
                if (StringUtils.isBlank(key)) {
                    if (!jsonElement.isJsonArray()) {
                        LOGGER.warn("can't find value by this childPath,path={}", sb.substring(1));
                        return null;
                    }
                    JsonArray asJsonArray = jsonElement.getAsJsonArray();
                    JsonElement res = asJsonArray.get(Integer.valueOf(index));
                    return res;
                } else {
                    JsonObject asJsonObject = jsonElement.getAsJsonObject();
                    JsonElement res = asJsonObject.get(key);
                    return res;
                }
            } else {
                JsonObject asJsonObject = jsonElement.getAsJsonObject();
                JsonElement res = asJsonObject.get(childPath);
                return res;
            }
    
        }
    
        public static void main(String[] args) {
            String str12 = "{\"additionJson\":{\"needPush\":true},\"id\":123456,\"date\":\"2013-4-13 12: 36: 54\"}";
            Boolean objectGson4Path12 = getObjectGson4Path(str12, "additionJson.needPush", Boolean.class);
            System.out.println(objectGson4Path12);
        }
    

     

    展开全文
  • 自己的一个SP工具类

    万次阅读 2017-01-23 14:12:53
    * SharedPreferences 的工具类 * Created by suwenlai on 16-12-23. */ public class SPUtil { /** * Sp 的文件名 */ public static String FILLNAME = "config"; /** * 存入某个 key 对应的 ....
    /**
     * SharedPreferences 的工具类
     * Created by suwenlai on 16-12-23.
     */
    
    public class SPUtil {
        /**
         * Sp 的文件名
         */
        public static String FILLNAME = "config";
    
        /**
         * 存入某个 key 对应的 value 值
         *
         * @param context  上下文
         * @param key       要存入的键
         * @param value     存入键对应的值
         */
        public static void put(Context context, String key, Object value) {
            SharedPreferences sp = context.getSharedPreferences(FILLNAME, Context.MODE_PRIVATE);
            SharedPreferences.Editor edit = sp.edit();
            if (value instanceof String) {
                edit.putString(key, (String) value);
            } else if (value instanceof Integer) {
                edit.putInt(key, (Integer) value);
            } else if (value instanceof Boolean) {
                edit.putBoolean(key, (Boolean) value);
            } else if (value instanceof Float) {
                edit.putFloat(key, (Float) value);
            } else if (value instanceof Long) {
                edit.putLong(key, (Long) value);
            }
            SharedPreferencesCompat.EditorCompat.getInstance().apply(edit);
        }
    
        /**
         * 得到某个 key 对应的值
         *
         * @param context   上下文
         * @param key       要取数据的键
         * @param defValue     没有读取到数据情况下  设置的默认值
         * @return  null
         */
        public static Object get(Context context, String key, Object defValue) {
            SharedPreferences sp = context.getSharedPreferences(FILLNAME, Context.MODE_PRIVATE);
            if (defValue instanceof String) {
                return sp.getString(key, (String) defValue);
            } else if (defValue instanceof Integer) {
                return sp.getInt(key, (Integer) defValue);
            } else if (defValue instanceof Boolean) {
                return sp.getBoolean(key, (Boolean) defValue);
            } else if (defValue instanceof Float) {
                return sp.getFloat(key, (Float) defValue);
            } else if (defValue instanceof Long) {
                return sp.getLong(key, (Long) defValue);
            }
            return null;
        }
    
        /**
         * 返回所有数据
         *
         * @param context 上下文
         * @return  所有数据的 Map 集合
         */
        public static Map<String, ?> getAll(Context context) {
            SharedPreferences sp = context.getSharedPreferences(FILLNAME, Context.MODE_PRIVATE);
            return sp.getAll();
        }
    
        /**
         * 移除某个 key 值已经对应的值
         *
         * @param context   上下文
         * @param key   要移除数据对应的键
         */
        public static void remove(Context context, String key) {
            SharedPreferences sp = context.getSharedPreferences(FILLNAME, Context.MODE_PRIVATE);
            SharedPreferences.Editor edit = sp.edit();
            edit.remove(key);
            SharedPreferencesCompat.EditorCompat.getInstance().apply(edit);
        }
    
        /**
         * 清除所有内容
         *
         * @param context   上下文
         */
        public static void clear(Context context) {
            SharedPreferences sp = context.getSharedPreferences(FILLNAME, Context.MODE_PRIVATE);
            SharedPreferences.Editor edit = sp.edit();
            edit.clear();
            SharedPreferencesCompat.EditorCompat.getInstance().apply(edit);
        }
    }

     

    展开全文
  • 出好代码 系列之 积累自己的工具类项目
  • kotlin 的Android toast工具类

    千次阅读 2019-01-03 09:28:02
    原文地址:... Google的时候翻到了一个别人用kotlin实现的toast工具类感觉很棒,特别记录一下: 实现 fun Any.toast(context: Context, duration: Int = Toast.LENGTH_SHORT): Toas...
  • 场景:有些工具类里面出现业务代码,导致工具类不好复用。只能在工具类新建一个类似方法勉强满足业务,但是这个工具类看起来就很low了。 解决:把工具类中的业务代码抽成一个方法,这个方法设置为抽象方法a...
  • Android之文件读写工具类

    千次阅读 2015-06-14 11:57:46
    工具类永久维护,永久更新,如果各位读者发现有bug或这不合理之处,欢迎指正,博主将第一时间改正。 以下是主要内容,本类主要功能有: 1.创建文件功能; 2.向文件中写入字节数组; 3.向文件中写入字符串; 4.从...
  • 自己一个数据库连接工具类

    千次阅读 2016-12-03 19:53:13
    最近刚复习了一下JDBC相关的知识,这里来一个mysql数据库连接工具类来练习一下。 在jdbc连接数据库时,Connection对象是非常稀有的资源,用完后必须马上释放,如果Connection不能及时、正确的关闭,极易导致系统...
  • 用python一个文件工具类

    千次阅读 2018-02-01 19:35:26
    #-*- coding:utf-8 -*- #写入数据的工具类 class FileManager(object): #保存文件名称 filename = 'student.txt' #一个写入数据的接口 @classmethod def write(cls, content, split = '\n'): ''' :par
  • 几个文件读写的工具类:文本文件读写、二进制文件读写、对象读写。其中对象读写工具类有错误,在试图进行多个对象读取时,读第二个对象就抛出异常,这是为什么?此外怎样把一个存放对象的文件中所有的对象读出来? ...
  • 一、概要由于笔者在开发中会涉及到对文件和文件夹的打包操作,所有自己了一个工具类用于打包文件二、老规矩,直接上源码import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java....
  • Java8中的LocalDateTime工具类

    万次阅读 多人点赞 2017-07-22 22:57:14
    网上搜索了半天都没有找到Java8的LocalDateTime的工具类,只好自己了一个,常用功能基本都有。还在用Date的Java同道该换换了。 个人项目地址:https://github.com/KingBoyWorld/common.git,Common模块中有很多...
  • hutool工具类

    千次阅读 2017-11-13 16:58:36
    一个Java基础工具类,类似于jodd...一个Java基础工具类,对文件、流、加密解密、转码、正则、线程、XML等JDK方法进行封装,组成各种Util工具类,同时提供以下组件: 布隆过滤 缓存 克隆接口 类型转换
  • ObjectMapper工具类

    千次阅读 2018-03-01 09:47:57
    ObjectMapper是Jackson库的主要。...它使用JsonParser和JsonGenerator的实例实现JSON实际的读/声明以下是org.codehaus.jackson.map.ObjectMapper的声明: public class ObjectMapper extends...
  • 小程序requestUtil工具类

    千次阅读 2018-03-29 16:55:16
    小程序工具类requestUtils 1.前言 开发小程序已经有一段时间了,都没有过小程序相关的文章,踩过坑挺多,把这些坑记下来,下次就不会再犯了。 小程序自带的请求方法不是特别方便,无意中得到了一个工具类,因此...
  • 教你出StringUtils工具类

    千次阅读 2017-02-24 10:19:28
    下面我就将我的StringUtil附上,分享给大家。 附上代码: /* *代码很简单,就是判断常用的字符串是不是满足一些条件 * *里面有判断字符串是不是url,还有构建url的代码等等。 * *还有很多更使用的判断,...
  • java手动分页工具类

    千次阅读 2019-03-04 14:14:20
    开发中,碰到了一些奇葩的业务逻辑,无法使用框架自身的分页功能,想了很久最后还是决定自己手写一个分页工具类,以备后续参考和使用,下面直接上代码, /** * 手动分页类 * @param datas * @param pageSize * ...
  • python引入自己工具类

    千次阅读 2016-09-28 01:25:37
    假设项目目录结构是: common --dateutils.py scrip --report.py 当我们在report.py中直接使用 from dateutils import DateUtils 会报找不到模块的错误:ImportError: No module named dateutils ...
  • Android 在工具类里面的Context应该怎么? 一直报NullPointerException ![图片说明](https://img-ask.csdn.net/upload/201511/12/1447314593_689802.png)
  • SpringBoot Redis工具类封装

    千次阅读 多人点赞 2019-06-18 19:50:53
    SpringBoot整合Redis的博客很多,...看了很多博客后,我成功的整合了,并了个Redis操作工具类。特意在此记录一下,方便后续查阅。 一、Maven依赖 1、本文所采用的SpringBoot的版本如下 <parent> <...
  • Java常用工具类汇总

    万次阅读 2021-03-04 16:03:15
    Java常用工具类汇总 时间工具类,根据本月时间获取上月一号零点零时零分零秒 java实现阿拉伯数字转换成中文数字显示 SpringBoot使用注解(@value)动态读取properties(yml)文件中配置信息 时间工具类,根据本月时间...
  • hadoop-common中虽然包含io工具类,但有可能下载的版本里面的io类版本太低,没有以下举例的方法可用 < dependency > < groupId > commons-io groupId > < artifactId > commons-io artifactId > < ...
  • JAVA常用工具类汇总

    万次阅读 多人点赞 2019-08-06 16:05:46
    一、字符串工具类 org.apache.commons.lang.StringUtils pom文件: <!-- https://mvnrepository.com/artifact/org.apache.commons/org.apache.commons.lang --> <dependency> <groupId>org.apache...
  • 小编最近忙着学习项目构架上的一些技术,把实用的工具类整理下,单独放在一个项目。其他项目需要用直接使用maven依赖一下就可以使用了。项目中需要实现上传多张图片,由于多张图片,又担心并发量大。所以小编做了一...
  • 整理收集的一些常用java工具类

    万次阅读 多人点赞 2017-08-20 19:42:14
    整理收集的一些常用java工具类
  • java工具类编写思考

    千次阅读 多人点赞 2018-09-06 08:55:11
    这篇博客的初衷是因为我想一个工具类,同时对工具类做出一些规范以及优化。 规范 工具类定义为final class,考虑到工具类应该不能被继承 工具类的命名应该用Util结尾,例如LogUtil 工具类的构造方法应该首选...
  • httpclient4.3工具类

    热门讨论 2014-05-29 16:53:42
    httpclient4.3开发的工具类,httpclientUtils 因为项目需要,自己就根据常用的了一个。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,220,410
精华内容 488,164
关键字:

工具类如何写