用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 来源:简书 著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
View Detailsjava项目通过maven依赖构建,一般依赖的jar文件都是通过maven配置后从本地仓库查找,如果没有则从中央仓库或私服中远程下载,但有时候引用的jar文件远程仓库中没有,则可以配置本地系统路径来引用,也可以先将本地的jar文件install到本地仓库或上传到远程仓库中。
View DetailsSPI 的全称是 Service Provider Interface, 即提供服务接口;是一种服务发现机制,SPI 的本质是将接口实现类的全限定名配置在文件中,并由服务加载器读取配置文件,加载实现类。这样可以在运行时,动态为接口替换实现类。正因此特性,我们可以很容易的通过 SPI 机制为我们的程序提供拓展功能。
View Details
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> |
View Details
在日常开发中经常需要测试一些代码的执行时间,但又不想使用向 JMH(Java Microbenchmark Harness,Java 微基准测试套件)这么重的测试框架,所以本文就汇总了一些 Java 中比较常用的执行时间统计方法。
View Details1.RedisTemplate常用方法
2.String类型
3.Hash类型
4.List类型
5.Set类型
6.zSet类型
Redis常用的数据类型:String、Hash、List、Set、zSet
当我们使用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; } |
View Details
获取当前时间,需要用到 PHP Date() 函数。 PHP Date() 把时间戳格式化为更易读的日期和时间。 语法:
1 |
date(format,timestamp) |
其中参数 format 为显示格式,参数 timestamp 为时间戳,是可选择的,默认为 time() ,即如果没有给出时间戳则使用本地当前时间。 format 格式参数在这里简单介绍几个: 一些常用于日期的字符: Y – 完整表示年份(四位数字:2019) y – 表示年份(两位数字:19) F – 表示月份(完整的文本格式: January 或者 March) M – 表示月份(3个字母:Jun) m – 表示月份,有前导0(数字:04) n – 表示月份,无前导0(数字:4) d – 表示月份中的第几天,有前导0(01-31) j – 表示月份中的第几天,无前导0(1-31) D – 表示星期几(3字母:Wed) l – 表示星期几(完整英文:Wednesday) w – 表示星期中的第几天(数字,0表示星期天) W – 表示一年中的第几周 z – 表示一年中的第几天(0-366) 实例:
1 2 3 4 5 6 |
<?php echo "<p>今天是:" . date("Y/m/d") . "</p>"; echo "<p>今天是:" . date("Y.m.d") . "</p>"; echo "<p>今天是:" . date("Y-m-d") . "</p>"; echo "<p>今天是:" . date("l") . "</p>"; ?> |
运行结果: 如果想要中文的年月日,可以这样写:
1 |
echo "现在时间是:" . date("Y年m月d日"); |
运行结果: 今天是:2019年04月24日 获得简单的时间: 常用于时间的字符: H – 24小时格式,有前导0(08,18) h – 12小时格式,有前导0(06,11) G – 24小时格式,无前导0(9,17) g – 12小时格式,无前导0(6,12) i – 表示分钟,有前导0(00-59) s […]
View Details1、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一致) […]
View Details