一切福田，不離方寸，從心而覓，感無不通。

Category Archives: Java

maven 构建能够运行的jar文件

用maven来构建过jar文件的朋友可能知道,默认情况下,maven因为不会给我们添加我们项目中需要的依赖,以及不会在MANIFEST.MF文件中添加Main-Class这一条目,造成我们构建完成的jar文件不能通过java -jar命令而直接执行,必须通过java -cp命令,指定类路径来执行.这无疑是非常麻烦的. Google了之后,找到了解决问题的方案.在pom.xml文件中,添加下面的snippet:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
    <build>
        <plugins>
            <!-- any other plugins -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.5.0</version>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <mainClass>org.longsheng.noobchain.NoobChain</mainClass>
                        </manifest>
                    </archive>
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

  把上面的snippet中的mainClass替换成你自己的主类的路径. 然后,就可以通过java -jar命令来执行构建好的jar文件了. 作者：AlstonWilliams 链接：https://www.jianshu.com/p/868889e32bd6 来源：简书 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

龙生   24 Mar 2023
View Details

maven引入本地jar不能打入部署包的问题解决

java项目通过maven依赖构建，一般依赖的jar文件都是通过maven配置后从本地仓库查找，如果没有则从中央仓库或私服中远程下载，但有时候引用的jar文件远程仓库中没有，则可以配置本地系统路径来引用，也可以先将本地的jar文件install到本地仓库或上传到远程仓库中。

龙生   20 Mar 2023
View Details

可插拔组件设计机制 —SPI

SPI 的全称是 Service Provider Interface, 即提供服务接口；是一种服务发现机制，SPI 的本质是将接口实现类的全限定名配置在文件中，并由服务加载器读取配置文件，加载实现类。这样可以在运行时，动态为接口替换实现类。正因此特性，我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。

龙生   15 Mar 2023
View Details

maven引jar包

1
2
3
4
5
6
7
<dependency>
<groupId>org.longsheng</groupId>
<artifactId>itemName</artifactId>
<version>1.0.0</version>
<scope>system</scope>
<systemPath>${project.basedir}/src/main/resources/lib/xxxx.jar</systemPath>
</dependency>

 

龙生   13 Mar 2023
View Details

Java统计代码的执行时间的N种方法

在日常开发中经常需要测试一些代码的执行时间，但又不想使用向 JMH（Java Microbenchmark Harness，Java 微基准测试套件）这么重的测试框架，所以本文就汇总了一些 Java 中比较常用的执行时间统计方法。

龙生   12 Mar 2023
View Details

RedisTemplate最全的常用方法

1.RedisTemplate常用方法
2.String类型
3.Hash类型
4.List类型
5.Set类型
6.zSet类型
Redis常用的数据类型：String、Hash、List、Set、zSet

龙生   08 Mar 2023
View Details

在Spring Boot中使用RedisTemplate的时候出现乱码

当我们使用RedisTemplate向我们的Redis数据库中set（“originName”）时，我们在服务端中获取该key的时候出现了乱码\xac\xed\x00\x05t\x00\noriginName` 原因：因为我们springboot中的RedisTemplate将我们的key保存的时候会将其进行序列化，此时我们在别的客户端获取的时候机会出现乱码。 解决：我们需要自己定义我们的RedisTemplate中的序列化机制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Configuration
public class RedisTemplateConfig {
 
    @Bean
    public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory connectionFactory){
        RedisTemplate<Object, Object> objectObjectRedisTemplate = new RedisTemplate<>();
        objectObjectRedisTemplate.setKeySerializer(new StringRedisSerializer());
        objectObjectRedisTemplate.setHashKeySerializer(new StringRedisSerializer());
 
        objectObjectRedisTemplate.setConnectionFactory(connectionFactory);
 
        return objectObjectRedisTemplate;
    }
 
}

由于我们获取值时会将它进行反序列化，我们就无须设置value的反序列化 from:https://blog.csdn.net/ebdbbd/article/details/126266968   另一个版本：

1
2
3
4
5
6
7
8
9
10
11
12
13
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory
            , GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer
            , StringRedisSerializer stringRedisSerializer) {
        RedisTemplate objectObjectRedisTemplate = new RedisTemplate();
        objectObjectRedisTemplate.setConnectionFactory(redisConnectionFactory);
        objectObjectRedisTemplate.setKeySerializer(stringRedisSerializer);
        objectObjectRedisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
        objectObjectRedisTemplate.setHashKeySerializer(stringRedisSerializer);
        objectObjectRedisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
        
        return objectObjectRedisTemplate;
    }

 

龙生   08 Mar 2023
View Details

Java对象深拷贝详解

1、Java中拷贝的概念 在Java语言中，拷贝一个对象时，有浅拷贝与深拷贝两种 浅拷贝：只拷贝源对象的地址，所以新对象与老对象共用一个地址，当该地址变化时，两个对象也会随之改变。 深拷贝：拷贝对象的所有值，即使源对象发生任何改变，拷贝的值也不会变化。 在User类的基础上，介绍两种浅拷贝案列 User类：

1
2
3
4
5
@Data
public class User {
    private String name;
    private Integer age;
}

  案列①：普通对象的浅拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.shuizhu.study;
//浅拷贝案例1
public class Study01 {
    public static void main(String[] args) {
        User user1 = new User();
        user1.setName("张三");
        user1.setAge(18);
        User user2 = user1;
        System.out.println("user1未改变前，user2的名字为：" + user2.getName());
        user1.setName("李四");
        System.out.println("user1未改变前，user2的名字为：" + user2.getName());
    }
}

  结果：改变user1后，user2的值也随之变化 案列②：List浅拷贝（这也是我们平时项目中，经常遇到的情况）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package com.shuizhu.study;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
//Java浅拷贝案列2
public class Study02 {
    public static void main(String[] args) {
        List<User> list1 = new ArrayList<>();
        User user1 = new User();
        user1.setName("张三");
        user1.setAge(18);
        User user2 = new User();
        user2.setName("李四");
        user2.setAge(19);
        list1.add(user1);
        list1.add(user2);
        //TODO 以下是开发中，经常发生的浅拷贝
        //方式1：通过new ArrayList方式，把list01拷贝给list02
        List<User> list2 = new ArrayList<>(list1);
        System.out.println("list1未改变前，list2的结果为：" + list2);
        //方式2：通过addAll方法，把list01拷贝给list02
        List<User> list3 = new ArrayList<>();
        list3.addAll(list1);
        System.out.println("list1未改变前，list3的结果为：" + list3);
        //方式3：通过stream流的方式，把list01拷贝给list02
        List<User> list4 = list1.stream().collect(Collectors.toList());
        System.out.println("list1未改变前，list4的结果为：" + list4);
        //改变list1集合中的user1对象
        System.out.println("--------------------------------------------");
        user1.setName("老六");
        user1.setAge(78);
        System.out.println("list1改变后，list2的结果为：" + list2);
        System.out.println("list1改变后，list3的结果为：" + list3);
        System.out.println("list1改变后，list4的结果为：" + list4);
    }
}

  结果：对List的3种拷贝，其实都是浅拷贝，当源集合中对象发生改变时，新的List也会随之变化 2、常见的深拷贝方式 构造函数方式（new的方式） 重写clone方法 Apache Commons Lang序列化 Gson序列化 Jackson序列化 2.1、构造函数方式 这种方式就是创建一个新的对象，然后通过源对象的get方法与新对象set方法，把源对象的值复制新对象，这里就不再演示了。 缺点：在拷贝的对象数量较少时，可以使用，但是对象数量过多时，会大大增加系统开销，开发中应避免使用。 2.2、重写clone方法 步骤： 1>需要拷贝对象的类，去实现Cloneable接口 2>重写clone方法 3>使用"对象.clone()"的方式进行拷贝 根据上面的案列，进行对应的改造： 首先是User实体类 ，如下：

1
2
3
4
5
6
7
8
9
10
@Data
public class User implements Cloneable{
    private String name;
    private Integer age;
    @Override
    protected User clone() throws CloneNotSupportedException {
        return (User) super.clone();
    }
}

  改造案列①：

1
2
3
4
5
6
7
8
9
10
11
12
13
package com.shuizhu.study;
//Java深拷贝案列
public class Study03 {
    public static void main(String[] args) throws CloneNotSupportedException {
        User user1 = new User();
        user1.setName("张三");
        user1.setAge(18);
        User user2 = user1.clone();
        System.out.println("user1未改变前，user2的名字为：" + user2.getName());
        user1.setName("李四");
        System.out.println("user1未改变前，user2的名字为：" + user2.getName());
    }
}

  结果：当user1改变后，user2的值不会改变 改造案列②：List类型深拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package com.shuizhu.study;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
//Java深拷贝案列
public class Study04 {
    public static void main(String[] args) {
        List<User> list1 = new ArrayList<>();
        User user1 = new User();
        user1.setName("张三");
        user1.setAge(18);
        User user2 = new User();
        user2.setName("李四");
        user2.setAge(19);
        list1.add(user1);
        list1.add(user2);
        /
        //通过clone方式，把list01拷贝给list02
        List<User> list2 = new ArrayList<>();  
        //TODO 当数据量多时，建议使用对象的方式，把List当做属性，然后拷贝哦到一个新的对象中，从而不需要循环，可以见Apache Commons Lang序列化深拷贝方式
        list1.forEach(user->{
            try {
                list2.add(user.clone());
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
        });
        System.out.println("list1未改变前，list2的结果为：" + list2);
        
        //改变list1集合中的user1对象
        System.out.println("--------------------------------------------");
        user1.setName("老六");
        user1.setAge(78);
        System.out.println("list1改变后，list2的结果为：" + list2);
    }
}

  结果：list1中的每个对象通过clone()添加list2中，当list1中的对象改变时，list2不会改变 2.3 、Apache Commons Lang序列化 步骤： 1>导入Commons包

1
2
3
4
5
<dependency>
   <groupId>org.apache.commons</groupId>
   <artifactId>commons-lang3</artifactId>
   <version>3:3.5</version>
</dependency>

  2>实体类实现Serializable接口

1
2
3
4
5
@Data
public class User implements Serializable {
    private String name;
    private Integer age;
}

  3>调用SerializationUtils工具类，实现深拷贝（注意：SerializationUtils不能直接拷贝List类型） 案列如下： 案列①：对象深拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.shuizhu.study2;
import org.apache.commons.lang3.SerializationUtils;
//Apache Commons Lang序列化实现对象的深拷贝
public class Study01 {
    public static void main(String[] args) {
        User user1 = new User();
        user1.setName("张三");
        user1.setAge(18);
        User user2 = SerializationUtils.clone(user1);
        System.out.println("user1未改变前，user2的名字为：" + user2.getName());
        user1.setName("李四");
        System.out.println("user1改变后，user2的名字为：" + user2.getName());
    }
}

  结果：user1的改变不会导致user2的改变，从而实现深拷贝 案列②：List类型深拷贝 （1）改造开始，我们先创建一个专门用于拷贝List<User>类型的实体类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.shuizhu.study2;
import java.io.Serializable;
import java.util.List;
/**
* @author 睡竹
* @date 2022/12/10
* 用于深拷贝时，不需要去遍历List<User>集合，只需要拷贝UserCopyDTO 对象就可以
* 获取到新的List<User>集合
*/
@Data
public class UserCopyDTO implements Serializable {//必须实现Serializable接口
    private List<User> users;
}

  （2）拷贝List类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package com.shuizhu.study2;
import org.apache.commons.lang3.SerializationUtils;
import java.util.ArrayList;
import java.util.List;
//Apache Commons Lang序列化实现List的深拷贝
public class Study02 {
    public static void main(String[] args) {
        List<User> list1 = new ArrayList<>();
        User user1 = new User();
        user1.setName("张三");
        user1.setAge(18);
        User user2 = new User();
        user2.setName("李四");
        user2.setAge(19);
        list1.add(user1);
        list1.add(user2);
        //使用UserCopyDTO对象，专门用于拷贝List<User>类型数据，不需要再去遍历list1
        UserCopyDTO userCopyDTO = new UserCopyDTO();
        userCopyDTO.setUsers(list1);
        //通过Apache Commons Lang序列化方式，把list01拷贝给list02
        UserCopyDTO clone = SerializationUtils.clone(userCopyDTO);
        List<User> list2 = clone.getUsers();
        System.out.println("list1未改变前，list2的结果为：" + list2);
        //改变list1集合中的user1对象
        System.out.println("--------------------------------------------");
        user1.setName("老六");
        user1.setAge(78);
        System.out.println("list1改变后，list2的结果为：" + list2);
    }
}

  结果：  2.4、Gson序列化 步骤： 1、导入Gson依赖

1
2
3
4
5
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.5</version>
</dependency>

  2>创建Gson对象，使用该对象进行深拷贝（实体类不再需要实现Serializable接口） 案例如下：只演示对象的深拷贝，LIst类型的深拷贝与之前的流程是相似的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.shuizhu.study3;
import com.google.gson.Gson;
//Gson序列化实现对象的深拷贝
public class Study01 {
    public static void main(String[] args) {
        User user1 = new User();
        user1.setName("张三");
        user1.setAge(18);
        Gson gson = new Gson();
        User user2 = gson.fromJson(gson.toJson(user1), User.class);
        System.out.println("user1未改变前，user2的名字为：" + user2.getName());
        user1.setName("李四");
        System.out.println("user1改变后，user2的名字为：" + user2.getName());
    }
}

  重点： 结果： 2.5、Jackson序列化 该方式与Gson原理、使用方式相似，但是Jackson序列化深拷贝，要求拷贝的对象必须有无参构造函数 步骤： 1>导入Jackson依赖

1
2
3
4
5
6
7
8
9
10
<dependency>
    <groupId>com.fasterxml.jackson</groupId>
    <artifactId>core</artifactId>
    <version>2.2.2</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson</groupId>
    <artifactId>databind</artifactId>
    <version>2.2.2</version>
</dependency>

  2>创建ObjectMapper对象，进行深拷贝（用法与Gson一致） […]

龙生   02 Mar 2023
View Details

Spring Boot配置文件读取中文乱码

【问题】在配置文件application.properties中配置一个值含有中文的变量。 spring加载配置之后，读取的变量中文部分出现乱码。 根据CSDN说的一堆办法，改encoding为UTF-8，都试过了统统不好使。 【解决方法】知乎上有人说： 配置文件可以用yml文件来代替properties文件， yml文件是支持中文的，并且利用换行缩进来避免重复的前缀。 照做之后问题解决。但是注意：data source中jdbc url中的转义符号反斜杠“\”必须去掉。   from:https://www.cnblogs.com/tigerhsu/p/9794072.html

龙生   27 Feb 2023
View Details
1 2 … 47

Copyright © 2023 Longsheng All rights reserved.