Java工具类

谁言0413

已于 2022-11-15 15:39:12 修改

阅读量617

点赞数

分类专栏：简易代码小操作 Spring boot 文章标签： java

于 2022-10-10 18:17:27 首次发布

本文链接：https://blog.csdn.net/qq_44188658/article/details/127240308

版权

Spring boot 同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

简易代码小操作

2 篇文章 0 订阅

订阅专栏

一、本人常用的HTTP Post请求的几种方式（代码）

1.HttpURLConnection

public String doPost(String URL,String jsonParams){
        OutputStreamWriter out = null;
        BufferedReader in = null;
        StringBuilder result = new StringBuilder();
        HttpURLConnection conn = null;
        try{
            URL url = new URL(URL);
            conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("POST");
            //发送POST请求必须设置为true
            conn.setDoOutput(true);
            conn.setDoInput(true);
            //设置连接超时时间和读取超时时间
            conn.setConnectTimeout(30000);
            conn.setReadTimeout(10000);
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setRequestProperty("Accept", "application/json");
            //获取输出流
            out = new OutputStreamWriter(conn.getOutputStream());
            out.write(jsonParams);
            out.flush();
            out.close();
            //取得输入流，并使用Reader读取
            if (200 == conn.getResponseCode()){
                in = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"));
                String line;
                while ((line = in.readLine()) != null){
                    result.append(line);
                    System.out.println(line);
                }
            }else{
                System.out.println("ResponseCode is an error code:" + conn.getResponseCode());
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if(out != null){
                    out.close();
                }
                if(in != null){
                    in.close();
                }
            }catch (IOException ioe){
                ioe.printStackTrace();
            }
        }
        return result.toString();
    }

2、CloseableHttpClient

		<dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
            <version>4.5.13</version>
        </dependency>

public static  String sendHttpPost(String url, JSONObject json , HashMap<String ,String > headers) {
        String jsonStr = json.toString();
        HttpPost post = new HttpPost(url);
        String response = "";
        RequestConfig config = RequestConfig.custom().setConnectionRequestTimeout(10000)
                .setConnectTimeout(10000).setSocketTimeout(10000).build();
        CloseableHttpClient client = null;
        try {
            client = HttpClients.custom().setDefaultRequestConfig(config)
                    .setSslcontext(SSLContexts.custom().loadTrustMaterial(null, (x509Certificates, s) -> true).build())
                    .setMaxConnTotal(500)
                    .setMaxConnPerRoute(200).build();
            for(Map.Entry<String,String> entry : headers.entrySet() ){
                post.addHeader(entry.getKey(), entry.getValue());
            }
            StringEntity requestBody = new StringEntity( jsonStr, "utf-8");
            post.setEntity(requestBody);
            CloseableHttpResponse httpResponse = client.execute(post);
            InputStream inStream = httpResponse.getEntity().getContent();
            BufferedReader reader = new BufferedReader(new InputStreamReader(inStream, "utf-8"));
            StringBuilder strber = new StringBuilder();
            String line;
            while ((line = reader.readLine()) != null) {
                strber.append(line + "\n");
            }
            inStream.close();
            response = strber.toString();
        } catch (Exception e) {
            logger.info(e.getStackTrace());
        } finally {
            try {
                client.close();
            } catch (Exception e) {
                logger.info(e.getStackTrace());
            }
        }
        return response;
    }

3.HttpEntity，restTemplate

		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

提前注入restTemplate的bean

@Configuration
public class BeanConfig {

    @Bean
    public RestTemplate restTemplate(ClientHttpRequestFactory factory) {
        return new RestTemplate(factory);
    }

    @Bean
    public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        //建⽴连接所⽤的时间，适⽤于⽹络状况正常的情况下，两端连接所⽤的时间。单位毫秒
        factory.setConnectTimeout(15000);
        //建⽴连接后从服务器读取到可⽤资源所⽤的时间。单位毫秒
        factory.setReadTimeout(5000);
        return factory;
    }
}

	public JsonResponse<Void> sendRecord2Server(UploadSnapRecordRequest uploadSnapRecordRequest) {
        try {
            HttpHeaders headers = new HttpHeaders();
            MimeType mimeType = MimeTypeUtils.parseMimeType("application/json");
            MediaType mediaType = new MediaType(mimeType.getType(), mimeType.getSubtype(), StandardCharsets.UTF_8);
            headers.setContentType(mediaType);
            HttpEntity<UploadSnapRecordRequest> entity = new HttpEntity<>(uploadSnapRecordRequest, headers);
            ResponseEntity<JsonResponse<Void>> resultEntity = restTemplate.exchange(ConfigService.BACKSTAGE_IMG_RUL, HttpMethod.POST, entity, new ParameterizedTypeReference<JsonResponse<Void>>() {
            });
            return resultEntity.getBody();
        } catch (Exception exception) {
            log.error("发送抓拍记录：{}时发生异常：{}", uploadSnapRecordRequest, exception.getMessage());
            return JsonResponse.fail(exception.getMessage());
        }
    }

二、MQTT连接

 		<dependency>
            <groupId>org.springframework.integration</groupId>
            <artifactId>spring-integration-mqtt</artifactId>
        </dependency>

package com.yf.iot.hotel.terminal.component;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.yf.iot.hotel.terminal.common.rest.JsonResponse;
import com.yf.iot.hotel.terminal.config.system.ConfigService;
import com.yf.iot.hotel.terminal.constant.GlobalConstant;
import com.yf.iot.hotel.terminal.hikvision.service.HkDeviceService;
import com.yf.iot.hotel.terminal.vo.BaseMqttMsg;
import com.yf.iot.hotel.terminal.vo.DeviceMsg;
import com.yf.iot.hotel.terminal.vo.FaceMsg;
import com.yf.iot.hotel.terminal.vo.VehicleMsg;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.eclipse.paho.client.mqttv3.*;
import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.UnsupportedEncodingException;
import java.util.Objects;

@Slf4j
@Service
public class MqttService {
    /**
     * 订阅主题
     */
    private final String[] topics = new String[4];
    /**
     * 消息等级，和主题数组一一对应，服务端将按照指定等级给订阅了主题的客户端推送消息
     */
    private final int[] qos = {1, 2, 2, 2};
    /**
     * 客户端对象
     */
    private MqttClient client;

    @Resource
    private HkDeviceService hkDeviceService;

    /**
     * 客户端连接服务端
     */
    public synchronized void connect() {
        try {
            String clientId = ConfigService.MQTT_CLIENT_ID;
            topics[0] = GlobalConstant.SERVER;
            topics[1] = GlobalConstant.DEVICE + clientId;
            topics[2] = GlobalConstant.VEHICLE + clientId;
            topics[3] = GlobalConstant.FACE + clientId;
            //创建MQTT客户端对象
            client = new MqttClient(ConfigService.MQTT_HOST_URL, clientId, new MemoryPersistence());
            //连接设置
            MqttConnectOptions options = new MqttConnectOptions();
            //是否清空session，设置false表示服务器会保留客户端的连接记录（订阅主题，qos）,客户端重连之后能获取到服务器在客户端断开连接期间推送的消息
            //设置为true表示每次连接服务器都是以新的身份
            options.setCleanSession(false);
            //设置连接用户名
            options.setUserName(ConfigService.MQTT_USER_NAME);
            //设置连接密码
            options.setPassword(ConfigService.MQTT_PASSWORD.toCharArray());
            //设置超时时间，单位为秒
            options.setConnectionTimeout(100);
            //设置心跳时间 单位为秒，表示服务器每隔 1.5*20秒的时间向客户端发送心跳判断客户端是否在线
            options.setKeepAliveInterval(20);
            //设置遗嘱消息的话题，若客户端和服务器之间的连接意外断开，服务器将发布客户端的遗嘱信息
            options.setWill("willTopic", (clientId + "与服务器断开连接").getBytes(), 0, false);
            //设置回调
            options.setAutomaticReconnect(true);
            client.setCallback(new MqttCallbackExtended() {
                @Override
                public void connectComplete(boolean b, String s) {
                    log.info("与服务器连接成功");
                    try {
                        client.subscribe(topics, qos);
                    } catch (MqttException mqttException) {
                        log.error("与服务器连接成功，订阅topic时发生异常：{}", mqttException.getMessage());
                    }
                }

                @Override
                public void connectionLost(Throwable throwable) {
                    log.warn("与服务器断开连接");
                }

                @Override
                public void messageArrived(String s, MqttMessage mqttMessage) throws UnsupportedEncodingException {
                    String content = new String(mqttMessage.getPayload());

                    log.info("收到消息 topic:{}, content:{}", s, content);
                  
                    switch (s) {
                        case GlobalConstant.FACE:
                            handleFaceMsg(content);
                            break;
                        default:
                            log.error("未实现的主题topic:{},content:{}", type, content);
                            break;
                    }
                }

                @Override
                public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) {
                    IMqttAsyncClient client = iMqttDeliveryToken.getClient();
                    log.info("{} 发布消息成功！", client.getClientId());
                }
            });
            client.connect(options);
        } catch (MqttException e) {
            log.error("连接MQTT服务时发生异常:{}", e.getMessage());
            client = null;
        }
    }

    /**
     * 断开连接
     */
    public synchronized void disConnect() {
        try {
            if (Objects.nonNull(client)) {
                client.unsubscribe(topics);
                client.disconnect();
                client.close(true);
                client = null;
            } else {
                log.warn("连接未初始化或已销毁");
            }
        } catch (MqttException e) {
            log.error("断开MQTT服务连接时发生异常:{}", e.getMessage());
        }
    }

    /**
     * 检查连接
     */
    public synchronized void checkConnection() {
        try {
            if (Objects.isNull(client) || !client.isConnected()) {
                connect();
            }
        } catch (Exception e) {
            log.error("定时判断Mqtt是否连接时发生异常：{}", e.getMessage());
        }
    }

    /**
     * 发布消息
     *
     * @param qos      Qos
     * @param retained 是否保留
     * @param topic    主题
     * @param message  内容
     */
    public void publish(int qos, boolean retained, String topic, String message) {
        try {
            if (Objects.nonNull(client)) {
                MqttMessage mqttMessage = new MqttMessage();
                mqttMessage.setQos(qos);
                mqttMessage.setRetained(retained);
                mqttMessage.setPayload(message.getBytes());
                //主题的目的地，用于发布/订阅信息
                MqttTopic mqttTopic = client.getTopic(topic);
                //提供一种机制来跟踪消息的传递进度
                //用于在以非阻塞方式（在后台运行）执行发布是跟踪消息的传递进度
                MqttDeliveryToken token;
                //将指定消息发布到主题，但不等待消息传递完成，返回的token可用于跟踪消息的传递状态
                //一旦此方法干净地返回，消息就已被客户端接受发布，当连接可用，将在后台完成消息传递。
                token = mqttTopic.publish(mqttMessage);
                token.waitForCompletion();
            } else {
                log.warn("连接未初始化或已销毁");
            }
        } catch (MqttException e) {
            log.error("发布消息(Qos:{},Retained:{},Topic:{},Message:{})时发生异常:{}", qos, retained, topic, message, e.getMessage());
        }
    }

}

三、常用的Redis工具类

  		<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

1.StringRedisTemplate

(1) 查询redis是否存在key

stringRedisTemplate.hasKey(key)

(2) 插入key-value

stringRedisTemplate.set(key,value)

(3) 插入有效期的key-value （string类型）

stringRedisTemplate.opsForValue().set(key,value,intValue,TimeUnit.MINUTES)//intValue指有效期长度，TimeUnit.MINUTES指的是分钟时间单位

(4) 删除某key

 stringRedisTemplate.delete(key)

(5) 右插入key-value （list类型）

stringRedisTemplate.opsForList().rightPush("student", JSON.toJSONString(students))

(6) 左删除key （list类型）

stringRedisTemplate.opsForList().rightPop(key);

(7) 获取value

String student = stringRedisTemplate.opsForValue().get("student");

四、逆向工程

maven插件

	<properties>
        <java.version>1.8</java.version>
        <javaModelGenerator.targetProject>${basedir}/src/main/java</javaModelGenerator.targetProject>
        <sqlMapGenerator.targetProject>${basedir}/src/main/resources</sqlMapGenerator.targetProject>
        <javaClientGenerator.targetProject>${basedir}/src/main/java</javaClientGenerator.targetProject>
        <mybatis.generator.configurationFile>${basedir}/src/main/resources/generatorConfig.xml</mybatis.generator.configurationFile>
        <mybatis.generator.overwrite>true</mybatis.generator.overwrite>
        <mybatis.generator.version>1.3.7</mybatis.generator.version>
    </properties>

 		<dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </dependency>

		<build>
        <plugins>

            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>

            <plugin>
                <configuration>
                    <verbose>true</verbose>
                    <overwrite>true</overwrite>
                    <configurationFile>src/main/resources/generator/generatorConfig.xml</configurationFile>
                </configuration>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.7</version>
                <dependencies>
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>8.0.15</version>
                    </dependency>
                    <dependency>
                        <groupId>org.yf</groupId>
                        <artifactId>my-mybatis-generator-core</artifactId>
                        <systemPath>${project.basedir}/src/main/resources/jars/mybatis-generator-core-1.3.7.jar
                        </systemPath>
                        <scope>system</scope>
                        <version>1.3.7</version>
                    </dependency>
                </dependencies>
            </plugin>
        </plugins>
    </build>

generatorConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <context id="mysqlTables" targetRuntime="MyBatis3">
        <property name="javaFileEncoding" value="UTF-8"/>
        <property name="addColumnAnnotation" value="false"/>
        <!--各类插件，也可以自己继承org.mybatis.generator.api.PluginAdapter开发插件-->
        <!--&lt;!&ndash; 生成一对多配置 &ndash;&gt;-->
        <!--&lt;!&ndash; 生成一对一配置 &ndash;&gt;-->
        <!--<plugin type="cc.bandaotixi.plugins.OneToOnePlugin" />-->
        <!--&lt;!&ndash; 生成一对多配置 &ndash;&gt;-->
        <!--<plugin type="cc.bandaotixi.plugins.OneToManyPlugin" />-->
        <!--&lt;!&ndash; 生成批量配置 &ndash;&gt;-->
        <!--<plugin type="cc.bandaotixi.plugins.BatchInsertPlugin" />-->
        <!--<plugin type="cc.bandaotixi.plugins.BatchUpdatePlugin" />-->

        <plugin type="org.mybatis.generator.plugins.RowBoundsPlugin"></plugin>
        <plugin type="org.mybatis.generator.plugins.SerializablePlugin"></plugin>
        <plugin type="org.mybatis.generator.plugins.EqualsHashCodePlugin"/>
        <plugin type="org.mybatis.generator.plugins.CaseInsensitiveLikePlugin"/>
        <plugin type="org.mybatis.generator.plugins.ToStringPlugin"/>
        <plugin type="org.mybatis.generator.plugins.UnmergeableXmlMappersPlugin"/>


        <commentGenerator type="org.mybatis.generator.internal.DefaultCommentGenerator">
            <!-- 这个元素用来去除指定生成的注释中是否包含生成的日期 false:表示保护 -->
            <!-- 如果生成日期，会造成即使修改一个字段，整个实体类所有属性都会发生变化，不利于版本控制，所以设置为true -->
            <property name="suppressDate" value="true"/>
            <!-- 是否去除自动生成的注释 true：是 ： false:否 -->
            <property name="suppressAllComments" value="false"/>
        </commentGenerator>

        <jdbcConnection driverClass="com.mysql.cj.jdbc.Driver"
                        connectionURL="jdbc:mysql://xxxxx:3306/xxx?nullCatalogMeansCurrent=true&amp;useUnicode=true&amp;characterEncoding=utf-8&amp;serverTimezone=GMT%2B8"
                        userId="root" password="root">
        </jdbcConnection>

        <javaTypeResolver>
            <property name="forceBigDecimals" value="false"/>
        </javaTypeResolver>

        <javaModelGenerator targetPackage="org.yf.entity"
                            targetProject="${javaModelGenerator.targetProject}">
            <property name="enableSubPackages" value="true"/>
            <property name="trimStrings" value="true"/>
<!--            <property name="rootClass" value="org.yf.common.baseModel.BaseModel"/>-->
        </javaModelGenerator>

        <sqlMapGenerator targetPackage="mapper"
                         targetProject="${sqlMapGenerator.targetProject}">
            <property name="enableSubPackages" value="true"/>
        </sqlMapGenerator>

        <javaClientGenerator type="XMLMAPPER"
                             targetPackage="org.yf.mapper"
                             targetProject="${javaClientGenerator.targetProject}">
            <property name="enableSubPackages" value="false"/>
<!--            <property name="rootInterface" value="org.yf.common.baseModel.BaseMapper"/>-->
        </javaClientGenerator>

      
        <table tableName="admin_role">
            <generatedKey column="id" sqlStatement="MySql" identity="true"/>
            <columnOverride column="role_state" javaType="java.lang.Integer"
                            typeHandler="org.yf.typehandler.IStateHandler"/>
        </table>

    </context>
</generatorConfiguration>

mybatis配置

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC
        "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <settings>
        <!-- 日志开启 -->
        <setting name="logImpl" value="STDOUT_LOGGING"/>

        <!-- 二级缓存开启 -->
        <setting name="cacheEnabled" value="true"/>
        <setting name="lazyLoadingEnabled" value="false"/>
        <setting name="aggressiveLazyLoading" value="true"/>
        <setting name="multipleResultSetsEnabled" value="true"/>
        <!-- 把数据库字段映射为驼峰式的字段 ，重要！！！-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    
</configuration>