Java on ffff65535

windows 环境运行jacob的一些报错处理

Sun, 13 Nov 2022 00:00:00 +0800

com.jacob.com.ComFailException: VariantChangeType failed

报错信息如下

com.jacob.com.ComFailException: VariantChangeType failed

解决方案： win2008 以下需要在 C:\Windows\System32\config\systemprofile\Desktop 建立文件夹 win2008 及以上需要在 C:\Windows\SysWOW64\config\systemprofile\Desktop

可以直接执行下边的powershell脚本创建

if((Test-Path "C:\Windows\System32\config\systemprofile\Desktop") -ne "True")
{
 New-Item -Path "C:\Windows\System32\config\systemprofile\Desktop" -ItemType Directory
}

if((Test-Path "C:\Windows\SysWOW64\config\systemprofile\Desktop") -ne "True")
{
 New-Item -Path "C:\Windows\SysWOW64\config\systemprofile\Desktop" -ItemType Directory
}

SaveAs Source: Microsoft PowerPoint Description: Presentation.SaveAs : PowerPoint 无法将 ^0 保存到 ^1。

报错信息如下

jdk11 httpclient的基本使用

Wed, 26 Oct 2022 15:00:00 +0800

构建请求参数java.net.http.HttpRequest

请求 URI
请求类型（GET、PUT、POST、DELETE）
请求体
超时时间
请求请求头

HttpRequest request = HttpRequest.newBuilder()
 // 请求url
 .uri(URI.create("http://openjdk.java.net/"))
 // 超时时间
 .timeout(Duration.ofMinutes(1))
 // 请求头
 .header("Content-Type", "application/json")
 // 请求类型GET、POST、PUT、DELETE
 .POST(HttpRequest.BodyPublishers.ofString("请求体"))
 .build();

发送请求java.net.http.HttpClient

首选协议版本（ HTTP/1.1 或 HTTP/2 ）
是否跟随重定向
代理
身份验证器

HttpClient client = HttpClient.newBuilder()
 // 首选协议版本 默认情况下，客户端将使用 HTTP/2发送请求。发送到尚不支持 HTTP/2的服务器的请求将自动降级为HTTP/1.1。
 .version(HttpClient.Version.HTTP_2)
 // 重定向策略
 .followRedirects(HttpClient.Redirect.NORMAL)
 // 代理
 .proxy(ProxySelector.of(new InetSocketAddress("www-proxy.com", 8080)))
 // 超时时间
 .connectTimeout(Duration.ofSeconds(6))
 .build();

 try {
 // 发送同步请求
 var response = client.send(request, HttpResponse.BodyHandlers.ofString());
 // 发送异步请求
 var future = client.sendAsync(request, HttpResponse.BodyHandlers.ofString());
 var responseAsync = future.get();
 } catch (IOException e) {
 throw new RuntimeException(e);
 } catch (InterruptedException e) {
 throw new RuntimeException(e);
 } catch (ExecutionException e) {
 throw new RuntimeException(e);
 }

直接使用默认设置发送请求

springboot 自定义校验注解

Fri, 20 May 2022 22:24:13 +0800

自定义校验注解ConstraintValidator 不太合适,优化一下

maven

<!-- Validation -->
<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

自定义校验注解

import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.*;

/**
 * 枚举校验注解
 *
 */
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Constraint(validatedBy = {EnumValidator.class})
public @interface EnumValid {
 String message() default "";

 Class<?>[] groups() default {};

 Class<? extends Payload>[] payload() default {};

 /**
 * 目标枚举类
 */
 Class<?> target() default Class.class;

}

注解校验逻辑

Spring cache + Redis LocalDateTime反序列化

Fri, 20 May 2022 22:21:21 +0800

/**
* DateTime格式化字符串
*/
private static final String DEFAULT_DATETIME_PATTERN = "yyyy-MM-dd HH:mm:ss";

/**
* Date格式化字符串
*/
private static final String DEFAULT_DATE_PATTERN = "yyyy-MM-dd";

/**
* Time格式化字符串
*/
private static final String DEFAULT_TIME_PATTERN = "HH:mm:ss";

private RedisCacheConfiguration getRedisCacheConfiguration() {

 // 配置序列化（解决乱码的问题）
 RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
 //Key序列化方式redisSerializer
 .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer()))
 .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer()))
 .disableCachingNullValues();
 return config;
}

/**
 * key 序列化
 *
 * @return
 */
private RedisSerializer<String> keySerializer() {
 return new StringRedisSerializer();
}

/**
 * 值采用JSON序列化
 *
 * @return
 */
private RedisSerializer<Object> valueSerializer() {
 Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
 // 解决查询缓存转换异常的问题
 ObjectMapper om = new ObjectMapper();
 om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
 om.activateDefaultTyping(new ObjectMapper().getPolymorphicTypeValidator(), ObjectMapper.DefaultTyping.NON_FINAL);
 jackson2JsonRedisSerializer.setObjectMapper(om);

 // Java8日期日期处理 LocalTime,LocalDate,LocalDateTime
 JavaTimeModule javaTimeModule = new JavaTimeModule();
 javaTimeModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATETIME_PATTERN)));
 javaTimeModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_PATTERN)));
 javaTimeModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_PATTERN)));
 javaTimeModule.addDeserializer(LocalDateTime.class, new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATETIME_PATTERN)));
 javaTimeModule.addDeserializer(LocalDate.class, new LocalDateDeserializer(DateTimeFormatter.ofPattern(DEFAULT_DATE_PATTERN)));
 javaTimeModule.addDeserializer(LocalTime.class, new LocalTimeDeserializer(DateTimeFormatter.ofPattern(DEFAULT_TIME_PATTERN)));
 om.registerModule(javaTimeModule);
 jackson2JsonRedisSerializer.setObjectMapper(om);
 return jackson2JsonRedisSerializer;
}

使用java终止office进程

Fri, 06 May 2022 20:08:45 +0800

需要jdk大于等于1.8,否则需要重写convertStr()方法

import lombok.extern.slf4j.Slf4j;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.stream.Collectors;

@Slf4j
public class KillUtils {

 private static final String kill_wscript = "taskkill /f /t /im wscript.exe";
 private static final String kill_WINWORD = "taskkill /f /t /im WINWORD.exe";
 private static final String kill_POWERPNT = "taskkill /f /t /im POWERPNT.exe";
 private static final String kill_EXCEL = "taskkill /f /t /im EXCEL.exe";

 public static void main(String[] args) throws IOException {
 killOffice();
 }

 public static synchronized void killOffice() throws IOException {
 log.info("------------------------start------------------------");
 Process wscript = Runtime.getRuntime().exec(kill_wscript);
 Process winword = Runtime.getRuntime().exec(kill_WINWORD);
 Process powerpnt = Runtime.getRuntime().exec(kill_POWERPNT);
 Process excel = Runtime.getRuntime().exec(kill_EXCEL);

 convertStr(wscript, kill_wscript);
 convertStr(winword, kill_WINWORD);
 convertStr(powerpnt, kill_POWERPNT);
 convertStr(excel, kill_EXCEL);
 log.info("------------------------end------------------------");
 }

 private static void convertStr(Process process, String name) {
 String inputMsg = new BufferedReader(process.inputReader()).lines().collect(Collectors.joining("\n"));
 log.info(name + "--input:{}", inputMsg);
 String errorMsg = new BufferedReader(process.errorReader()).lines().collect(Collectors.joining("\n"));
 log.info(name + "--error:{}", errorMsg);
 }
}

windows使用指定版本jdk启动jar包

Wed, 20 Apr 2022 14:33:31 +0800

windows server中已经配置了一个1.8版本的jdk

现在有一个使用jdk17的jar也要运行

CMD执行报错

C:\test>C:\Program Files\Java\openjdk-17.0.2_windows-x64_bin\jdk-17.0.2\bin\java.exe -jar test-0.0.1-SNAPSHOT.jar
'C:\Program' 不是内部或外部命令，也不是可运行的程序
或批处理文件。

原因是Program Files中间有一个空格，给java.exe的整个路径加上双引号

线程池

Mon, 21 Mar 2022 22:26:29 +0800

参考资料：

https://www.bilibili.com/video/BV1V4411p7EF?p=27

https://blog.csdn.net/lxy13263050001/article/details/122723983

背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大
思路：提前创建了好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具
好处：
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 便于线程管理
  - corePoolSize：核心池的大小
  - maximumPoolSize：最大线程数
  - keepAliveTime：线程没有任务是最多保持多长时间后会终止

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author
 */
public class TestPool {
 public static void main(String[] args) {
 // 创建有10个线程的线程池
 ExecutorService threadPool = Executors.newFixedThreadPool(10);
 threadPool.execute(new TestMyThread());
 threadPool.execute(new TestMyThread());
 threadPool.execute(new TestMyThread());
 threadPool.execute(new TestMyThread());
 // 关闭线程池
 threadPool.shutdown();
 }
}

class TestMyThread implements Runnable {

 @Override
 public void run() {
 for (int i = 0; i < 100; i++) {
 System.out.println(Thread.currentThread().getName() + "----->" + i);
 }
 }
}

JDK5.0起提供了线程池相关API：ExecutorService和Executors
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
- Future submit(Callable task)：执行任务，有返回值，一般又来执行Callable
- void shutdown() ：关闭连接池
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
- Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
- Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
- Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
- Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行

并发协作模型(生产者/消费者模式)-->信号灯法

Mon, 21 Mar 2022 22:26:01 +0800

方法名	作用
wait()	Object wait() 方法让当前线程进入等待状态。直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。
wait(long timeout)	Object wait(long timeout) 方法让当前线程处于等待(阻塞)状态，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过参数 timeout 设置的超时时间。
如果 timeout 参数为 0，则不会超时，会一直进行等待，类似于 wait() 方法。
notify()	Object notify() 方法用于唤醒一个在此对象监视器上等待的线程。
如果所有的线程都在此对象上等待，那么只会选择一个线程，选择是任意性的，并在对实现做出决定时发生。
notifyAll()	Object notifyAll() 方法用于唤醒在该对象上等待的所有线程。优先级别高的线程有限调度。
notifyAll() 方法跟 notify() 方法一样，区别在于 notifyAll() 方法唤醒在此对象监视器上等待的所有线程，notify() 方法是一个线程。

https://www.runoob.com/java/java-object-wait.html

并发协作模型(生产者/消费者模式)-->管程法

Mon, 21 Mar 2022 22:25:31 +0800

方法名	作用
wait()	Object wait() 方法让当前线程进入等待状态。直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。
wait(long timeout)	Object wait(long timeout) 方法让当前线程处于等待(阻塞)状态，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过参数 timeout 设置的超时时间。
如果 timeout 参数为 0，则不会超时，会一直进行等待，类似于 wait() 方法。
notify()	Object notify() 方法用于唤醒一个在此对象监视器上等待的线程。
如果所有的线程都在此对象上等待，那么只会选择一个线程，选择是任意性的，并在对实现做出决定时发生。
notifyAll()	Object notifyAll() 方法用于唤醒在该对象上等待的所有线程。优先级别高的线程有限调度。
notifyAll() 方法跟 notify() 方法一样，区别在于 notifyAll() 方法唤醒在此对象监视器上等待的所有线程，notify() 方法是一个线程。

https://www.runoob.com/java/java-object-wait.html

自定义校验注解ConstraintValidator

Tue, 15 Mar 2022 20:52:53 +0800

新建一个枚举类，限制请求参数中的属性值只能等于枚举中的值

public enum EnumType {
 /**
 * 数组中是要等于的值每增加一个要校验的类型，
 * 增加一个对应枚举类
 */
 // 性别
 GENDER_TYPE(new String[]{"0", "1"}),
 // 年级
 GRADE_TYPE(new String[]{"1", "2", "3"});

 private String[] values;

 EnumType(String[] values) {
 this.values = values;
 }

 public String[] getValues() {
 return values;
 }
}

新建一个自定义注解

守护(daemon)线程

Mon, 14 Mar 2022 17:50:40 +0800

线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕
- 如：后台记录操作日志，监控内存，垃圾回收等待…

public class TestThreadDaemon {
 public static void main(String[] args) {
 God god = new God();
 Thread godThread = new Thread(god);
 // 默认是false，表示用户线程
 godThread.setDaemon(true);
 godThread.start();

 // 你 用户线程启动
 new Thread(new You()).start();

 // 用户线程执行完毕，守护线程也会停止
 }
}

// 上帝 守护线程
class God implements Runnable {

 @Override
 public void run() {
 while (true) {
 System.out.println("上帝保佑着你");
 }
 }
}

// 你 用户线程
class You implements Runnable {
 @Override
 public void run() {
 System.out.println("=======hello world=======");
 for (int i = 0; i < 35600; i++) {
 System.out.println("你一生都开心活着");
 }
 System.out.println("=======goodbye world=======");
 }
}

参考资料：

线程优先级

Mon, 14 Mar 2022 17:50:06 +0800

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行
线程优先级用数字表示，范围从1~10（线程的调度由CPU决定，数字越大概率越大）
- Thread.MIN_PRIORITY = 1
- Thread.NORM_PRIORITY = 5
- Thread.MAX_PRIORITY = 10
使用以下方法改变或获取线程优先级
- getPriority()
- setPriority(int xxx)

public class TestThreadPriority {
 public static void main(String[] args) {
 // 打印主线程默认优先级
 System.out.println(Thread.currentThread().getName() + "====" + Thread.currentThread().getPriority());

 Priority priority = new Priority();

 Thread t1 = new Thread(priority, "t1");
 Thread t2 = new Thread(priority, "t2");
 Thread t3 = new Thread(priority, "t3");
 Thread t4 = new Thread(priority, "t4");
 Thread t5 = new Thread(priority, "t5");
 Thread t6 = new Thread(priority, "t6");

 t1.start();
 t2.setPriority(1);
 t2.start();
 t3.setPriority(4);
 t3.start();
 t4.setPriority(Thread.MAX_PRIORITY);
 t4.start();
 t5.setPriority(6);
 t5.start();
 t6.setPriority(8);
 t6.start();
 }
}

class Priority implements Runnable {
 @Override
 public void run() {
 System.out.println(Thread.currentThread().getName() + "====" + Thread.currentThread().getPriority());
 }
}

参考资料：

观测线程状态

Mon, 14 Mar 2022 17:49:32 +0800

线程状态

NEW
尚未启动的线程处于此状态
RUNNABLE
在java虚拟机中执行的线程处于此状态
BLOCKED
被阻塞等待监听器锁定的线程处于此状态
WAITING
正在等待另一个线程执行特定动作的线程处于此状态
TIMED_WAITING
正在等待另一个线程执行动作到达指定等待时间的线程处于此状态
TERMINATED
已退出的线程处于此状态

public enum State {
 NEW,
 RUNNABLE,
 BLOCKED,
 WAITING,
 TIMED_WAITING,
 TERMINATED;
}

/**
 *观察测试线程的状态
*/
public class TestThreadState {
 public static void main(String[] args) {
 Thread thread = new Thread(() -> {
 for (int i = 0; i < 10; i++) {
 try {
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 System.out.println("////////");
 }
 }, "观测线程");
 // 观察状态 NEW
 System.out.println(thread.getState());

 // 观察启动后
 thread.start();
 // RUNNABLE
 System.out.println(thread.getState());

 // 线程不终止一直输出状态
 while (thread.getState() != Thread.State.TERMINATED) {
 try {
 Thread.sleep(100);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 // TIMED_WAITING
 System.out.println(thread.getState());
 }
 //TERMINATED
 System.out.println(thread.getState());
 }
}

参考资料：

lambda表达式

Mon, 14 Mar 2022 17:48:51 +0800

函数式接口(Functional Interface)就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。

函数式接口可以被隐式转换为 lambda 表达式。

操作线程

Mon, 14 Mar 2022 17:47:00 +0800

线程停止

建议线程正常停止—->利用此时，不建议死循环
建议使用标志位—->设置一个标志位
不要使用stop或destroy等过时或jdk不建议使用的方法

/**
 * 测试停止线程
 * 1.建议线程正常停止---->利用此时，不建议死循环
 * 2.建议使用标志位---->设置一个标志位
 * 3.不要使用stop或destroy等过时或jdk不建议使用的方法
 */
public class TestThredStop implements Runnable {
 // 设置一个标志位
 private boolean flag = true;

 public static void main(String[] args) {
 TestThredStop testThredStop = new TestThredStop();
 new Thread(testThredStop).start();
 for (int i = 0; i < 1000; i++) {
 System.out.println("i=" + i);
 if (i == 900) {
 // 调用stop方法停止线程以转换标志位
 testThredStop.stop();
 System.out.println("线程停止了");
 }
 }
 }

 /**
 * 设置一个公开的方法用于停止线程，转换标志位
 */
 public void stop() {
 this.flag = false;
 }

 @Override
 public void run() {
 int i = 0;
 while (flag) {
 System.out.println("run正在执行" + i++);
 }
 }
}

参考资料：

线程的三种创建方式

Mon, 14 Mar 2022 17:03:00 +0800

继承Thread类

继承Thread类型
重写run方法
调用start开启多线程

线程的执行顺序无法控制，由CPU调度执行

public class TestThread extends Thread {
 public static void main(String[] args) {
 // 创建一个线程对象，调用start()方法
 TestThread testThread = new TestThread();
 // 调用start方法开启多线程(观察打印日志会发现：run方法和main方法交替执行)
 testThread.start();
 // 调用run方法，(观察打印日志会发现：会先执行run方法，再执行main方法)
 //testThread.run();
 // 主线程
 for (int i = 0; i < 200; i++) {
 System.out.println("main方法线程--" + i);
 }
 }

 /**
 * 1.继承Thread类型
 * 2.重写run方法
 */
 @Override
 public void run() {
 super.run();
 // run方法线程体
 for (int i = 0; i < 200; i++) {
 System.out.println("run方法线程--" + i);
 }
 }

}

参考资料：

windows server环境documents4j转换excel报错

Mon, 14 Mar 2022 16:50:00 +0800

错误描述：ppt和wrod可以正常转换，excel转换报错

报错信息如下

com.documents4j.throwables.FileSystemInteractionException: Could not access target file
	at com.documents4j.util.Reaction$FileSystemInteractionExceptionBuilder.make(Reaction.java:180)
	at com.documents4j.util.Reaction$ExceptionalReaction.apply(Reaction.java:75)
	at com.documents4j.conversion.ExternalConverterScriptResult.resolve(ExternalConverterScriptResult.java:70)
	at com.documents4j.conversion.ProcessFutureWrapper.evaluateExitValue(ProcessFutureWrapper.java:50)
	at com.documents4j.conversion.ProcessFutureWrapper.get(ProcessFutureWrapper.java:38)
	at com.documents4j.conversion.ProcessFutureWrapper.get(ProcessFutureWrapper.java:11)
	at com.documents4j.job.AbstractFutureWrappingPriorityFuture.run(AbstractFutureWrappingPriorityFuture.java:78)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
	at java.lang.Thread.run(Unknown Source)

解决方案：

使用documents4j将转换office为pdf

Mon, 14 Mar 2022 16:43:00 +0800

使用documents4j将word、excel、ppt转换为pdf

仅支持windows环境转换，需要安装MS office

<dependency>
 <groupId>com.documents4j</groupId>
 <artifactId>documents4j-local</artifactId>
 <version>1.1.7</version>
</dependency>
<dependency>
 <groupId>com.documents4j</groupId>
 <artifactId>documents4j-transformer-msoffice-word</artifactId>
 <version>1.1.7</version>
</dependency>
<dependency>
 <groupId>com.documents4j</groupId>
 <artifactId>documents4j-transformer-msoffice-excel</artifactId>
 <version>1.1.7</version>
</dependency>
<dependency>
 <groupId>com.documents4j</groupId>
 <artifactId>documents4j-transformer-msoffice-powerpoint</artifactId>
 <version>1.1.7</version>
</dependency>

使用的依赖