精华内容
下载资源
问答
  • utils工具类

    2018-12-26 16:49:00
    使用工具类的方法 目录结构 o代表项目层 util.js 用promise避免异步获取不到数据的问题 注意module.exports var APIURL = ''; function getApi(params){ // 返回一个Promise实例对象 return new Promise(...

    使用工具类的方法


    目录结构

    o代表项目层
    目录结构

    util.js

    用promise避免异步获取不到数据的问题

    注意module.exports

    var APIURL = '';
    function getApi(params){
      // 返回一个Promise实例对象
      return new Promise((resolve, reject) => {
        wx.request({
          url: APIURL,
          data: params,
          method: 'GET',
          header: {
            'content-type': 'application/json'
          },
          success: res=>resolve(res)
          ,
          fail: res => resolve({})
        })
      })
    }
    module.exports={
      getApi:getApi
    }
    

    page1.js

    var utils=require('../../utils/util.js')
    page({
        onLoad:function(e){
            utils.getApi({
                a:'lalalalala'
            }).then(res=>{
                console.log(res.data)
            })
        }
    
    })
    
    

    转载于:https://www.cnblogs.com/guanzhuqing/p/10426452.html

    展开全文
  • RedisUtils工具类

    2020-09-04 15:27:14
    RedisUtils工具类(转载) /** * Redis工具类 */ @Component public final class RedisUtil { private RedisTemplate redisTemplate; //注入自定义的RedisTemplate public void setRedisTemplate...

    RedisUtils工具类(转载)

    @Component
    public final class RedisUtil {
    
        @Resource
        private RedisTemplate<String, Object> redisTemplate;
    
        // =============================common============================
    
        /**
         * 指定缓存失效时间
         *
         * @param key  键
         * @param time 时间(秒)
         */
        public boolean expire(String key, long time, TimeUnit timeUnit) {
            try {
                if (time > 0) {
                    redisTemplate.expire(key, time, timeUnit);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 根据key 获取过期时间
         *
         * @param key 键 不能为null
         * @return 时间(秒) 返回0代表为永久有效
         */
        public long getExpire(String key) {
            return redisTemplate.getExpire(key, TimeUnit.SECONDS);
        }
    
    
        /**
         * 判断key是否存在
         *
         * @param key 键
         * @return true 存在 false不存在
         */
        public boolean hasKey(String key) {
            try {
                return redisTemplate.hasKey(key);
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 删除缓存
         *
         * @param key 可以传一个值 或多个
         */
        @SuppressWarnings("unchecked")
        public void del(String... key) {
            if (key != null && key.length > 0) {
                if (key.length == 1) {
                    redisTemplate.delete(key[0]);
                } else {
                    redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
                }
            }
        }
    
    
        // ============================String=============================
    
        /**
         * 普通缓存获取
         *
         * @param key 键
         * @return 值
         */
        public Object get(String key) {
            return key == null ? null : redisTemplate.opsForValue().get(key);
        }
    
        /**
         * 普通缓存放入
         *
         * @param key   键
         * @param value 值
         * @return true成功 false失败
         */
    
        public boolean set(String key, Object value) {
            try {
                redisTemplate.opsForValue().set(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 普通缓存放入并设置时间
         *
         * @param key   键
         * @param value 值
         * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
         * @return true成功 false 失败
         */
    
        public boolean set(String key, Object value, long time) {
            try {
                if (time > 0) {
                    redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
                } else {
                    set(key, value);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 递增
         *
         * @param key   键
         * @param delta 要增加几(大于0)
         */
        public long incr(String key, long delta) {
            if (delta < 0) {
                throw new RuntimeException("递增因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, delta);
        }
    
    
        /**
         * 递减
         *
         * @param key   键
         * @param delta 要减少几(小于0)
         */
        public long decr(String key, long delta) {
            if (delta < 0) {
                throw new RuntimeException("递减因子必须大于0");
            }
            return redisTemplate.opsForValue().increment(key, -delta);
        }
    
    
        // ================================Map=================================
    
        /**
         * HashGet
         *
         * @param key  键 不能为null
         * @param item 项 不能为null
         */
        public Object hget(String key, String item) {
            return redisTemplate.opsForHash().get(key, item);
        }
    
        /**
         * 获取hashKey对应的所有键值
         *
         * @param key 键
         * @return 对应的多个键值
         */
        public Map<Object, Object> hmget(String key) {
            return redisTemplate.opsForHash().entries(key);
        }
    
        /**
         * HashSet
         *
         * @param key 键
         * @param map 对应多个键值
         */
        public boolean hmset(String key, Map<String, Object> map) {
            try {
                redisTemplate.opsForHash().putAll(key, map);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * HashSet 并设置时间
         *
         * @param key  键
         * @param map  对应多个键值
         * @param time 时间(秒)
         * @return true成功 false失败
         */
        public boolean hmset(String key, Map<String, Object> map, long time, TimeUnit timeUnit) {
            try {
                redisTemplate.opsForHash().putAll(key, map);
                if (time > 0) {
                    expire(key, time, timeUnit);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         *
         * @param key   键
         * @param item  项
         * @param value 值
         * @return true 成功 false失败
         */
        public boolean hset(String key, String item, Object value) {
            try {
                redisTemplate.opsForHash().put(key, item, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
        /**
         * 向一张hash表中放入数据,如果不存在将创建
         *
         * @param key   键
         * @param item  项
         * @param value 值
         * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
         * @return true 成功 false失败
         */
        public boolean hset(String key, String item, Object value, long time, TimeUnit timeUnit) {
            try {
                redisTemplate.opsForHash().put(key, item, value);
                if (time > 0) {
                    expire(key, time, timeUnit);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 删除hash表中的值
         *
         * @param key  键 不能为null
         * @param item 项 可以使多个 不能为null
         */
        public void hdel(String key, Object... item) {
            redisTemplate.opsForHash().delete(key, item);
        }
    
    
        /**
         * 判断hash表中是否有该项的值
         *
         * @param key  键 不能为null
         * @param item 项 不能为null
         * @return true 存在 false不存在
         */
        public boolean hHasKey(String key, String item) {
            return redisTemplate.opsForHash().hasKey(key, item);
        }
    
    
        /**
         * hash递增 如果不存在,就会创建一个 并把新增后的值返回
         *
         * @param key  键
         * @param item 项
         * @param by   要增加几(大于0)
         */
        public double hincr(String key, String item, double by) {
            return redisTemplate.opsForHash().increment(key, item, by);
        }
    
    
        /**
         * hash递减
         *
         * @param key  键
         * @param item 项
         * @param by   要减少记(小于0)
         */
        public double hdecr(String key, String item, double by) {
            return redisTemplate.opsForHash().increment(key, item, -by);
        }
    
    
        // ============================set=============================
    
        /**
         * 根据key获取Set中的所有值
         *
         * @param key 键
         */
        public Set<Object> sGet(String key) {
            try {
                return redisTemplate.opsForSet().members(key);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
    
        /**
         * 根据value从一个set中查询,是否存在
         *
         * @param key   键
         * @param value 值
         * @return true 存在 false不存在
         */
        public boolean sHasKey(String key, Object value) {
            try {
                return redisTemplate.opsForSet().isMember(key, value);
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 将数据放入set缓存
         *
         * @param key    键
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public long sSet(String key, Object... values) {
            try {
                return redisTemplate.opsForSet().add(key, values);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
    
        /**
         * 将set数据放入缓存
         *
         * @param key    键
         * @param time   时间(秒)
         * @param values 值 可以是多个
         * @return 成功个数
         */
        public long sSetAndTime(String key, long time, TimeUnit timeUnit, Object... values) {
            try {
                Long count = redisTemplate.opsForSet().add(key, values);
                if (time > 0) {
                    expire(key, time, timeUnit);
                }
                return count;
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
    
        /**
         * 获取set缓存的长度
         *
         * @param key 键
         */
        public long sGetSetSize(String key) {
            try {
                return redisTemplate.opsForSet().size(key);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
    
        /**
         * 移除值为value的
         *
         * @param key    键
         * @param values 值 可以是多个
         * @return 移除的个数
         */
    
        public long setRemove(String key, Object... values) {
            try {
                Long count = redisTemplate.opsForSet().remove(key, values);
                return count;
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
        // ===============================list=================================
    
        /**
         * 获取list缓存的内容
         *
         * @param key   键
         * @param start 开始
         * @param end   结束 0 到 -1代表所有值
         */
        public List<Object> lGet(String key, long start, long end) {
            try {
                return redisTemplate.opsForList().range(key, start, end);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
    
        /**
         * 获取list缓存的长度
         *
         * @param key 键
         */
        public long lGetListSize(String key) {
            try {
                return redisTemplate.opsForList().size(key);
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
        }
    
    
        /**
         * 通过索引 获取list中的值
         *
         * @param key   键
         * @param index 索引 index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
         */
        public Object lGetIndex(String key, long index) {
            try {
                return redisTemplate.opsForList().index(key, index);
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         */
        public boolean lSet(String key, Object value) {
            try {
                redisTemplate.opsForList().rightPush(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         * @param time  时间(秒)
         */
        public boolean lSet(String key, Object value, long time,TimeUnit timeUnit) {
            try {
                redisTemplate.opsForList().rightPush(key, value);
                if (time > 0) {
                    expire(key, time,timeUnit);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
    
        }
    
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         * @return
         */
        public boolean lSet(String key, List<Object> value) {
            try {
                redisTemplate.opsForList().rightPushAll(key, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
    
        }
    
    
        /**
         * 将list放入缓存
         *
         * @param key   键
         * @param value 值
         * @param time  时间(秒)
         * @return
         */
        public boolean lSet(String key, List<Object> value, long time,TimeUnit timeUnit) {
            try {
                redisTemplate.opsForList().rightPushAll(key, value);
                if (time > 0) {
                    expire(key, time,timeUnit);
                }
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 根据索引修改list中的某条数据
         *
         * @param key   键
         * @param index 索引
         * @param value 值
         * @return
         */
    
        public boolean lUpdateIndex(String key, long index, Object value) {
            try {
                redisTemplate.opsForList().set(key, index, value);
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    
    
        /**
         * 移除N个值为value
         *
         * @param key   键
         * @param count 移除多少个
         * @param value 值
         * @return 移除的个数
         */
    
        public long lRemove(String key, long count, Object value) {
            try {
                Long remove = redisTemplate.opsForList().remove(key, count, value);
                return remove;
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
    
        }
    
        // ===============================HyperLogLog=================================
    
        public long pfadd(String key, String value) {
            return redisTemplate.opsForHyperLogLog().add(key, value);
        }
    
        public long pfcount(String key) {
            return redisTemplate.opsForHyperLogLog().size(key);
        }
    
        public void pfremove(String key) {
            redisTemplate.opsForHyperLogLog().delete(key);
        }
    
        public void pfmerge(String key1, String key2) {
            redisTemplate.opsForHyperLogLog().union(key1, key2);
        }
    
    
    }
    
    
    展开全文
  • 主要介绍了Spring Utils工具类常用方法实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Android Utils 工具类 好用# 多年工作心血总结~~~~~~~~~~~
  • javautils工具类

    2018-04-13 19:30:32
    java utils 常见的工具类 包括excel的操作等等 java utils 常见的工具类 包括excel的操作等等 java utils 常见的工具类 包括excel的操作等等
  • HttpClientUtils 工具类

    千次阅读 2019-01-15 16:06:24
    HttpClientUtils 工具类  package util; import com.alibaba.fastjson.JSONObject; import org.apache.http.HttpEntity; import org.apache.http.HttpStatus; import org.apache....

    HttpClientUtils 工具类 

    package util;
    
    import com.alibaba.fastjson.JSONObject;
    import org.apache.http.HttpEntity;
    import org.apache.http.HttpStatus;
    import org.apache.http.client.config.RequestConfig;
    import org.apache.http.client.methods.CloseableHttpResponse;
    import org.apache.http.client.methods.HttpGet;
    import org.apache.http.client.methods.HttpPost;
    import org.apache.http.entity.StringEntity;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import org.apache.http.util.EntityUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    import java.io.IOException;
    
    /**
     * HttpClient工具类
     * @author wangmx
     */
    public class HttpClientUtils
    {
        private static Logger logger = LoggerFactory.getLogger(HttpClientUtils.class); // 日志记录
    
        private static RequestConfig requestConfig = null;
    
        static
        {
            // 设置请求和传输超时时间
            requestConfig = RequestConfig.custom().setSocketTimeout(2000).setConnectTimeout(2000).build();
        }
    
        /**
         * post请求传输json参数
         * @param url  url地址
         * @param json 参数
         * @return
         */
        public static JSONObject httpPost(String url, JSONObject jsonParam)
        {
            // post请求返回结果
            CloseableHttpClient httpClient = HttpClients.createDefault();
            JSONObject jsonResult = null;
            HttpPost httpPost = new HttpPost(url);
            // 设置请求和传输超时时间
            httpPost.setConfig(requestConfig);
            try
            {
                if (null != jsonParam)
                {
                    // 解决中文乱码问题
                    StringEntity entity = new StringEntity(jsonParam.toString(), "utf-8");
                    entity.setContentEncoding("UTF-8");
                    entity.setContentType("application/json");
                    httpPost.setEntity(entity);
                }
                CloseableHttpResponse result = httpClient.execute(httpPost);
                // 请求发送成功,并得到响应
                if (result.getStatusLine().getStatusCode() == HttpStatus.SC_OK)
                {
                    String str = "";
                    try
                    {
                        // 读取服务器返回过来的json字符串数据
                        str = EntityUtils.toString(result.getEntity(), "utf-8");
                        // 把json字符串转换成json对象
                        jsonResult = JSONObject.parseObject(str);
                    }
                    catch (Exception e)
                    {
                        logger.error("post请求提交失败:" + url, e);
                    }
                }
            }
            catch (IOException e)
            {
                logger.error("post请求提交失败:" + url, e);
            }
            finally
            {
                httpPost.releaseConnection();
            }
            return jsonResult;
        }
    
        /**
         * post请求传输String参数 例如:name=Jack&sex=1&type=2
         * Content-type:application/x-www-form-urlencoded
         * @param url            url地址
         * @param strParam       参数
         * @return
         */
        public static JSONObject httpPost(String url, String strParam)
        {
            // post请求返回结果
            CloseableHttpClient httpClient = HttpClients.createDefault();
            JSONObject jsonResult = null;
            HttpPost httpPost = new HttpPost(url);
            httpPost.setConfig(requestConfig);
            try
            {
                if (null != strParam)
                {
                    // 解决中文乱码问题
                    StringEntity entity = new StringEntity(strParam, "utf-8");
                    entity.setContentEncoding("UTF-8");
                    entity.setContentType("application/x-www-form-urlencoded");
                    httpPost.setEntity(entity);
                }
                CloseableHttpResponse result = httpClient.execute(httpPost);
                // 请求发送成功,并得到响应
                if (result.getStatusLine().getStatusCode() == HttpStatus.SC_OK)
                {
                    String str = "";
                    try
                    {
                        // 读取服务器返回过来的json字符串数据
                        str = EntityUtils.toString(result.getEntity(), "utf-8");
                        // 把json字符串转换成json对象
                        jsonResult = JSONObject.parseObject(str);
                    }
                    catch (Exception e)
                    {
                        logger.error("post请求提交失败:" + url, e);
                    }
                }
            }
            catch (IOException e)
            {
                logger.error("post请求提交失败:" + url, e);
            }
            finally
            {
                httpPost.releaseConnection();
            }
            return jsonResult;
        }
    
        /**
         * 发送get请求
         * @param url 路径
         * @return
         */
        public static JSONObject httpGet(String url)
        {
            // get请求返回结果
            JSONObject jsonResult = null;
            CloseableHttpClient client = HttpClients.createDefault();
            // 发送get请求
            HttpGet request = new HttpGet(url);
            request.setConfig(requestConfig);
            try
            {
                CloseableHttpResponse response = client.execute(request);
    
                // 请求发送成功,并得到响应
                if (response.getStatusLine().getStatusCode() == HttpStatus.SC_OK)
                {
                    // 读取服务器返回过来的json字符串数据
                    HttpEntity entity = response.getEntity();
                    String strResult = EntityUtils.toString(entity, "utf-8");
                    // 把json字符串转换成json对象
                    jsonResult = JSONObject.parseObject(strResult);
                }
                else
                {
                    logger.error("get请求提交失败:" + url);
                }
            }
            catch (IOException e)
            {
                logger.error("get请求提交失败:" + url, e);
            }
            finally
            {
                request.releaseConnection();
            }
            return jsonResult;
        }
    
    }

     

    展开全文
  • Java聊天室 IO流 Socket流 GUI界面 工具类Utils代码及解释(FileUtils文件发送的工具类Utils PathUtils是设置背景图片的图片路径Utils工具类 ScreenUtils是获取电脑屏幕大小的工具 BackGroundPanel图片绘制工具类) ...

    Java聊天室 IO流 Socket流 GUI界面 工具类Utils代码及解释(FileUtils文件发送的工具类Utils PathUtils是设置背景图片的图片路径Utils工具类 ScreenUtils是获取电脑屏幕大小的工具 BackGroundPanel图片绘制工具类)

    FileUtils

    package SanWa.Util;
    
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    
    public class FileUtils {
        public static byte[] readFile(String path) {
            File file = new File(path);
            byte datas[] = null;
            if (!file.exists()) {
                datas = null;
            } else {
                try {
                    ByteArrayOutputStream baos = new ByteArrayOutputStream();
                    FileInputStream fis = new FileInputStream(file);
                    byte data[] = new byte[1024 * 1024];
                    int len = 0;
                    while ((len = fis.read(data)) > 0) {
                        baos.write(data, 0, len);
                    }
                    datas = baos.toByteArray();
                    baos.flush();
                    baos.close();
                    fis.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return datas;
        }
    
        public static boolean writeFile(String path, byte datas[]) {
            try {
                File file = new File(path);
                FileOutputStream fos = new FileOutputStream(file);
                fos.write(datas);
                fos.flush();
                fos.close();
                return true;
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
    }
    
    
    • writeFile 客户端进行接收文件时调用的方法 用来接收服务端发送来的文件
    • readFile客户端进行文件发送时读取文件的方法
    • 使用的是ByteArrayOutputStream用于多个的累计

    PathUtils

    package SanWa.Util;
    
    public class PathUtils {
        //获取路径
        private static final String IMG_PATH="ChatRoom\\Image\\";
        public static String getRealPath(String relativePath) {
            return IMG_PATH + relativePath;
        }
    }
    
    • 路径的获取

    ScreenUtils

    package SanWa.Util;
    
    import java.awt.*;
    
    public class ScreenUtils {
        //获取电脑屏幕的宽度
        public static int getScreenWidth() {
            return Toolkit.getDefaultToolkit().getScreenSize().width;
        }
    
        //获取电脑屏幕的高度
        public static int getScreenHeight() {
            return Toolkit.getDefaultToolkit().getScreenSize().height;
        }
    }
    
    • 获取电脑屏幕的宽度
    • 获取电脑屏幕的高度

    BackGroundPanel

    package SanWa.UI;
    
    import javax.swing.*;
    import java.awt.*;
    
    public class BackGroundPanel extends JPanel {
        //声明图片
        private Image backIcon;
    
        public BackGroundPanel(Image backIcon) {
            this.backIcon = backIcon;
        }
    
        public void paintComponent(Graphics g) {
            super.paintComponent(g);
            //绘制背景
            g.drawImage(backIcon,0,0,this.getWidth(),this.getHeight(),null);
    
        }
    }
    
    • 背景的绘制Utils工具类
    展开全文
  • java utils 工具类

    2016-08-01 19:09:05
    java 工具类,包含上传下载工具类,数据库工具类,验证码工具类,分页工具类,字符编码过滤工具类,字符串工具类 提醒:我已打包,在/WEB-INF/lib/itbofeng-utils.jar中,可以看到源码。 测试下载文件时修改servlet...
  • 简单HttpClientUtils工具类 package com.zy.utils; import org.apache.http.HttpEntity; import org.apache.http.HttpStatus; import org.apache.http.client.config.RequestConfig; im....
  • 本篇文章小编给大家分享一下Spring Utils工具类常用方法代码实例,文章代码介绍的很详细,小编觉得挺不错的,现在分享给大家供大家参考,有需要的小伙伴们可以来看看。Spring提供的工具类,主要用于框架内部使用,这...
  • ExcelUtils 工具类

    2018-01-31 22:15:57
    用于数据库数据导出到Excel表的java工具类,适合多种格式
  • java redisUtils工具类很全

    千次阅读 2019-09-22 22:00:35
    GitHub地址:... redisUtils工具类: package com.citydo.utils; import org.springframework.data.redis.connection.DataType; import org.springframework.data.redis.core...
  • httpClient是javaEE语言中用于接口调用的框架,本案例封装好了httpClientUtils工具类,用于发送GET和POST请求,直接将此工具类复制到你的项目中就可以了。第一步:httpClient jar包可采用maven方式下载,version版本...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,789
精华内容 3,115
关键字:

utils工具类