
。。。。。
//一个数据库连接池 db2数据库
<bean id="dataSource1" class="com.alibaba.druid.pool.DruidDataSource" destory-method="close">
    <property name="dirverClassName" value="com.ibm.db2.jcc.DB2Driver">
    <property name="url" value="jdbc:XXXXXXXXXXXX">
    <property name="username" value="XXXX">
    <property name="password" value="XXXX">
    .....//略 具体的数据连接池的细节配置
</bean>
 
//另一个一个数据库连接池 mysql数据库
<bean id="dataSource2" class="com.alibaba.druid.pool.DruidDataSource" destory-method="close">
    <property name="dirverClassName" value="com.mysql.jdbc.Driver">
    <property name="url" value="jdbc:XXXXXXXXXXXX">
    <property name="username" value="XXXX">
    <property name="password" value="XXXX">
    .....//略 具体的数据连接池的细节配置
</bean>
。。。。。

2、使用@configuration注解注入到spring容器中，这样在启动项目的时候，spring会自动将DB2JdbcTemplat、mysqlJdbcTemplate 注入到容器中，示例如下：


@Configuration
public class JdbcTemplateConfig {
 
    / *Bean 用于把当前方法的返回值作为对象存入spring的ioc容器中
      属性：name 作用：用于指定baan的id,默认值为方法名 */
    @Bean(name ="DB2JdbcTemplate")
    public JdbcTemplate myBean(@Qualifier("dataSouce1")DataSource dataSource) {
        return  new JdbcTemplate(dataSource);
    }
 
    @Bean(name ="mySqlJdbcTemplate")
    public JdbcTemplate myBean(@Qualifier("dataSouce2")DataSource dataSource) {
        return  new JdbcTemplate(dataSource);
    }
}

3、使用注入的数据源应用示例：


@Repository
public class myDaoImpl{
 
 @Autowired
 @Qualifier("mySqlJdbcTemplate")
 privare JdbcTemplate mySqlJDBC;
 
 @Autowired
 @Qualifier("db2JdbcTemplate")
 privare JdbcTemplate db2JDBC;
 
 
 
 
//查询示例
public List<User> findUser(String name){
 //此sql是原生的sql，即可以在数据库执行的sql
 String sql = "select * from user where name=?"
 // name处 那个参数 其实是可变参数，一般把参数多的情况下放入到list中，使用list.toArray()
   List<user>  list =db2JDBC.query(sql,new BeanPropertyRowMapper<>(User.class),name);
 
}
 
 
//插入示例
public void create(final String name,final int age){
  String sql="insert into user(id,name,age) value(?,?,?)";
  db2JDBC.update(sql,new PreparedStatementSetter(){
   @Override
   public void setValues(PreparedStatement ps)throw SQLException{
    ps.setString(1,UUIDUtil.genericUUID());
    ps.setString(2,name);
    ps.setInt(3,age);
   }
     
 })
 
 
//删除示例
public void deleteData(String id){
   String sql="delete user where id=?";
   db2JDBC.update(sql,id);
 
}
 
}
 
 
 
......
具体函数中 使用jdbcTemplate的方法即可：
常用的有：（技巧：可以 在sql对每个字段进行 参考 XXEntity属性  进行取别名 就可以直接映射进去了 如 select aa  student_age from XX  解释： 数据库aa表示学生年龄的字段，实体属性为 studentAge）
 
1、query(将参数都拼接到字符串的sql语句, new BeanPropertyRowMapper(XXEntity.class))
2、query(?代替参数sql语句, new BeanPropertyRowMapper(XXEntity.class)，（参数放入到）数组)
 
 
 
}

Spring @Configuration 注解介绍 - 简书


@Configuration
public class AppConfig {
 
    @Bean
    public MyBean myBean() {
        // instantiate, configure and return bean ...
    }
}

2、DB2分页查询

公司使用的数据库是db2，不像mysql那样可以使用 limit 0,10 这样的语法。

所以需要使用：给查询出的结果加一列“序号”，再对序号进行区间选取：


select * from (
select row_number() over( order by XXX) as rownum, a.*,b.* from tableA left join tableB on
tableA.id =tableB.id where 1=1 XXXXX拼接条件
)where rownum>? and rownum<=?

注意：

1、row_number() over(这里一定要排序否则每次查出来的顺序可能都在变化，导致每页可能存在重复的数据)。

2、 where rownum>? and rownum<=? 一定是单独存在的一个条件，切勿拼接到条件组合的where中，否则会导致有时候查出来的数据也正常，有时候不正常，why?因为对查询的结果进行排序，同时还对行号进行筛选，就会导致筛选出的结果的序号可能不是连续的。

3、记得，db2 分页是取区间。而支持limit的数据库 limit 起始位置，每页取的个数。别记混了。

4、经验：能在java处理的尽量用程序处理，数据库关联2张表，再多就不太好了，应有java小批量查询处理的思想。

3、多线程的快捷写法

使用lamba表达式：（不必再去单独写继承runable的线程类，再重写run方法，现在直接通过：向Thread类传入 （）->{ 要运行的程序}，线程名称 即可）


package com.alipay.sofa.boot.examples.demo;
 
public class MultiThread1 {
 
    public static void main(String[] args) {
        //  lamba表达式  ()->创建对象的意思
        new Thread(() -> {
            fun("线程11111");
        },"线程11"
        ).start();
 
        new Thread(() -> {
            fun("线程2222222222");
        },"线程22"
        ).start();
    }
 
 
    static void fun(String threadName){
        for (int i = 0; i < 1000; i++) {
            System.out.println("执行"+threadName);
        }
    }
}

原始的写法：

1、实现runable接口：


package com.alipay.sofa.boot.examples.demo;
 
public class MultiThread {
 
 
    static class MyThread implements Runnable {
        private String threadName;
 
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                System.out.println("执行" + threadName);
            }
        }
 
        public MyThread(String threadName) {
            this.threadName = threadName;
        }
    }
 
    public static void main(String[] args) {
 
        MyThread myThread1= new MyThread("线程111");
        MyThread myThread2= new MyThread("线程22");
 
        // 需要首先实例化一个 Thread，并传入自己的 MyThread
        Thread thread1 = new Thread(myThread1);
        Thread thread2 = new Thread(myThread2);
        
        thread1.start();
        thread2.strat();
 
 
    }
}

2、使用继承Thread的方式实现：


package com.alipay.sofa.boot.examples.demo;
 
public class MultiThread2 {
 
 
    static class MyThread extends Thread {
        private String threadName;
 
        @Override
        public void run() {
            for (int i = 0; i < 1000; i++) {
                System.out.println("执行" + threadName);
            }
        }
 
        public MyThread(String threadName) {
            this.threadName = threadName;
        }
    }
 
    public static void main(String[] args) {
 
        MyThread myThread1= new MyThread("线程111");
        MyThread myThread2= new MyThread("线程22");
 
       //继承Thread不用再放入到Thread中
 
        myThread1.start();
        myThread2.start();
 
 
    }
}

三种方式的的运行结果都是这种交替出现的结果：

注意的点：实现多线程的两种方式：

①类A继承Thread类，重写run方法，调用时直接 new A().strat() 即可

②类A实现 Runable接口，实现run方法，调用时需要把A传入Thread类中。如： new Thread(new A()).strat()

③lamba表达式： new Thread(()->{ 线程执行的语句 }).start()

线程涉及到的函数：

sleep（）和 wait() : Thread.sleep(1000), 不释放同步锁， wait（）是Object方法,需要通过notify、notifyAll唤醒；
yield() 使当前线程让出cpu，进入到就绪队列中，存在刚到就绪队列又被拿去执行的情况。
join()，通过用于当前线程等到其他线程的结束。如：
```
 
Thread t1=new Thread(()->{ 
 语句块;
}) ;
 
t1.join()；
Thread t2=new Thread(()->{ 
语句块;
}).start() ;
 
在t2线程里调用t1，表示 t1执行完成 才执行t2
--------------------------------------------------------------------
 
或者：
Thread t1=new Thread(()->{ 
 语句块;
}) ;
 
 
Thread t2=new Thread(()->{ 
t1.join()；
语句块;
}).start() ;
 
在t2线程里调用t1，表示 t1执行完成 才执行t2
```
一、wait()和sleep()的区别
1、wait()是object类的方法，sleep()是Thread类的方法，

2、wait()使线程进入等待状态，并且释放了锁，使得其他线程能使用同步控制块或方法，需要使用notify()或notifyAll()方法来唤醒线程，进入就绪状态，再去抢占cpu资源；

sleep()方法是线程进入睡眠状态，不释放锁；在睡眠时间用完后或使用interrupt()方法中断，线程唤醒进入进入就绪状态；（sleep()方法只是让出CPU，并不会让出同步资源锁）

3、sleep()方法必须捕获异常，wait()、notify()、notifyAll()方法同样必须需要捕获异常；

扩展：FutureTask的使用

上面提到的都是基本线程的用户，实际开发过程中都是使用线程池，一般使用如下：


 public void startTask() {
        List<String> siteCampinArnList = this.getSiteCampinArn();
        List<FutureTask<String>> taskList = new ArrayList<>();
        for (String site : siteCampinArnList) {
            FutureTask<String> task = new FutureTask<String>(new Callable<String>() {
                @Override
                public String call() throws Exception {
                     //todo 要运行的函数内容
                    return site+"成功";
                }
            });
            executorService.execute(task); //这里是 线程池 通过bean注入
            taskList.add(task);
        }
    }
 
 
///
线程池的使用
 
    @Bean
    public ExecutorService executorService(){
        ThreadFactory springThreadFactory = new CustomizableThreadFactory("openserch-pool-");
        return  new ThreadPoolExecutor(8, 8, 1,
                TimeUnit.MINUTES,
                new java.util.concurrent.LinkedBlockingQueue<Runnable>(),
                springThreadFactory);
    }

扩展：如何让线程按顺序输出？

1、使用线程池，该线程池只有一个线程，每个任务用submit提交到线程池。

2、使用join() 每个线程，调用自己的join（）函数。本质上是，主线程等待子线程完成，再顺序执行余下的线程。注意的是：


        //这样是无效的， 调用start() 就意味着 这个线程可能已经在执行
        thread1.start();
        thread2.start();
        thread3.start();
        //再调用join() 已经无用了
        thread1.join();
        thread2.join();
        thread3.join();
 
 
//正确的写法是：
 thread1.start();
 thread1.join();
 
 thread2.start();
 thread2.join();
 
 thread3.start();

扩展2：如何判定线程是否执行结束？

方法①：线程实例.isAlive(); 线程启动后，只要没有运行完毕，都会返回true

a.join也可以,表示a执行完前，后面的执行都挂起

方法②：使用Thread.activeCount()方法判断当前线程的线程组中活动线程的数目，为1时其他线程运行完毕

方法③：使用线程池java.util.concurrent.Executors，线程池启动后，执行线程池的shutdown()方法，即在所有线程执行完毕后关闭线程池，也能检测到线程关闭

4、同样的项目，同样的数据库，但拷贝到另一个电脑，登录失败

场景：新人入场，我拷贝了一份旧代码作为练习项目发给他，结果我的电脑可以运行，可以登录进系统。他的电脑却死活登录不进去。

原因：maven部分依赖的jar包未导入项目，导致登录失败。

注意：把自己的maven拷贝到新人电脑上，他的maven不一定能下载下来jar，原因是可能你1年前下载的，公司私服上已经删除了但是你本地仓库已经下载了，所以你的项目并不缺少，但是新人使用你的项目，pom文件依赖的jar 可能在远程仓库上不存在了。

扩展：maven知识：

maven的配置文件：setting.xml

1.profile
profiles下面可以配置多个repositories，用profile下不同的id进行区分。当不设置activeProfiles时,配置了多个profile时，默认是都有效，会依次进行尝试下载。

2.mirrors：要去下载jar包的地址
mirror是仓库的镜像备份，通过mirrorOf配置来拦截对应的repositories,想要拦截特定的repositories，就在mirrorOf配置上repository的id进行拦截，也可以配置*来拦截所有仓库，在不配置仓库时默认的仓库id为central。
3.server ：认证时用，用于私服认证
当仓库需要认证时，需要配置，server的id需要与repositories保持一致生效。很多大佬说server可以和pom文件里的repositories可以一起使用，不清楚能否和settings里的repositories一起使用。

额外的：有的项目需要依赖自己的jar或者模块，所以运行项目时，先lifecycle中先mvn install一下。

5、上传文件、下载文件

前端：


<!DOCTYPE html>
<html lang="en">
<head>
    <script src="https://code.jquery.com/jquery-3.1.1.min.js"></script>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<a href="/donwFileTest">下载</a>
 
 
<form  enctype="multipart/form-data" method="post">
    <span>上传</span>
    <input id="myUpload" name="file" type="file">
</form>
 
 
 
</body>
</html>
 
<script>
    $("#myUpload").on('change',function (){
        console.log("上传");
 
        //获取文件  不可省略取【0】
        var file =$('#myUpload')[0].files[0];
        var formData = new FormData();
        formData.append("file",file);
        $.ajax({
            url:"/uploadFileTest",
            dataType:'json',
            type:'POST',
            async: false,
            data: formData,
            processData : false, // 使数据不做处理
            contentType : false, // 不要设置Content-Type请求头
            success:function (result){
                alert("上传成功了")
            }
        })
    })
</script>

上传文件：


package com.alipay.sofa.boot.examples.demo.controller;
 
import org.apache.tomcat.util.http.fileupload.IOUtils;
import org.springframework.core.io.ClassPathResource;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;
 
import javax.servlet.http.HttpServletResponse;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
 
 
@Controller
public class DownFile {
 
    @RequestMapping("/index")
    public String index(HttpServletResponse response) throws IOException {
 
        return "index1.html";
    }
 
   
 
    @RequestMapping("/uploadFileTest")
    public void uploadFileTest(Model model, @RequestParam(value = "file", required = false) MultipartFile file) throws IOException {
        if (!file.isEmpty()) {
            byte[] buffer = new byte[1024 * 1024];
            int byteread = 0;
            FileOutputStream fs = new FileOutputStream("C:/Users/wjw\\Documents\\资料\\fileName");
            fs.write(buffer, 0, byteread);
            
        } else {
            model.addAttribute("result", "上传失败");
            return;
        }
 
    }
}

下载文件所在的目录：

下载文件代码：


package com.alipay.sofa.boot.examples.demo.controller;
 
import org.apache.tomcat.util.http.fileupload.IOUtils;
import org.springframework.core.io.ClassPathResource;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
 
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
 
 
 
@Controller
public class DownFile {
 
    @RequestMapping("/donwFileTest")
    public  void downFile(HttpServletResponse response) throws IOException{
 
        //该文件存在项目 resources文件夹下：
        String fileName="file.txt";
 
        //设置强制下载不打卡
        response.setContentType("application/force-download");
        response.addHeader("Content-Disposition","attachment;fileName="+fileName);
 
        //读取文件
        ClassPathResource cpr = new ClassPathResource(""+fileName); //路径从resources下开始
        InputStream is=cpr.getInputStream();
        IOUtils.copy(is,response.getOutputStream());
        response.flushBuffer();
 
        //关闭流
        if(is!=null){
            is.close();
        }
    }
}

6、关键词：ArrayList toString（）空格容易踩的坑

场景：有时候想要使用获取list的元素拼接成字符串，于是：

list.toString().replace("[",").replace("]","");

问题：这种拼接会在每个元素前有一个逗号和空格，后面再使用此字符串会出现问题。

解决：推荐使用原生自带的拼接

String str = String.join(",",myList);

7、Entity转换Vo对象技巧。po转vo

后台查出实体对象，往往需要转换成Vo对象，向前台展示，实际开发中，很多时候 Vo的字段与实体对象的字段名是有重复的，如果遍历 List<entity> 一个一个set到Vo对象，十分繁琐，这时候可以使用：BeanUtils.copyproperties(entrity,nXXVo());


//spring提供的工具类
 
for(User user:userList){
    BeanUtils.copyproperties(user,new UserVo());
}

注：需要实体的字段、类型和Vo的字段、类型都一致才能设置进去，否则设不进去。对应字段不一样的可以手动set

经验：此方法对后续维护其实不是很方便

8、sql查询玄学。关键词：sql limit hive

场景：查询hive表。使用limit n,m 进行分页。得到的数据不符合预期；具体原因：

user表中符合王二的数据有100+条，如下sql，但取出来的数据只有18条。和预期20条不符合。

select * from user  where name like '王二%'  limit 0,20 //取前20条数据

原因：移除关键字查询查询结果符合预期：查出来了20条数据

select * from user    limit 0,20 //取前20条数据

分析：既然移除关键字的拼接就能正常查询，不移除就不行。那应该是这个关键字有问题。

后来发现 hive 一般是数据文件或者解析导入的数据，存在某些字段的数据可能有空格（坑啊）。

所以对应hive表的关键字查询需要对关键字段名加trim(). 如下：


select * from user  where name like '王二%'  limit 0,20 //取前20条数据  原先的如果user某行name列存在 “ 王二” 这时候就查不出来。
 
所以对应hive表 关键字查找的 均一股脑的：(只适用于字符串 类型的，日期类型的不可以加)
 
 select * from user  where trim(name) like '王二%'  limit 0,20

注：trim(表字段XX),表示对该列 XX的数据均去空格处理

9、前端传后端数据。错误 400，排除技巧

场景：前端向后台传参数，后台用对象接收，报错400。

原因：一般是因为前端传参不符合接收对象的属性。即：不匹配。但是传参多时，一个一个核对很耗时，也不一定能核对出来原因。

技巧：在后台参数列表里，多加一个：BindingResult ,可以查看具体不匹配的字段。


public String list(BindingResult b,Model model, User user){
}

情况一：前端传json格式的数据

后端：使用 @RequestBody注解标记在依据json对象转的java对象即可

情况二：前端传get请求携带的参数

后端：使用@RequestParam注解可以指定参数绑定到当前参数，并可设置默认值

@RequestParam 可以用来接收Get POST类型的请求

@RequestBody 可以用来接收POST请求json格式的参数

10、排查工具的使用：Arthas、jvm总结

调优的目的：为了减少SWT,即：stop world time。每次发生full gc 都会造成系统的卡顿，所以要尽量避免，full gc.

一般的性能调优都是jstack，但比较好用的是阿里巴巴开发的 Arthas 性能调优非常强大，

官方文档：快速入门 — Arthas 3.5.4 文档

使用方法：

1)、下载jar包

2)、运行jar包

java -jar arthas-boot-jar

3、输入你想要查看某jar应用程序的序号，再回车，会出现：

4、比如上图发现 ID 为8的线程占用cpu 88%，所以现在查看该线程，使用命令 thread 8 即可打印出现移除的源代码：

2、常遇到的问题：系统应用频繁的full gc,导致用户体验差。

分析:性能调优，不得不先了解jvm的内存模块：

①堆：

线程共享，是minor gc 和full gc 垃圾回收的主要地方。
空间划分：新生代、老年代 。默认占内存空间 1:2
- 新生代又分：eden区、s0区、s1区。默认占空间比例是8:1:1。
标记整理算法：是老年代的
深刻讨论：
问题1：为什么堆内存要分为新生代和老年代？
- 答：因为JAVA对象90%以上的对象都是朝生夕死的，其中GC回收的成本很高，为了提高性能所以将新生成的对象放在Eden区，将扛过多次GC的“老家伙”放在老年代
问题2：那为什么新生代还需要继续细分?
- 答：因为Eden区的绝大部分对象寿命很短，那么Eden每次满了清理垃圾，存活的对象被迁移到老年区，老年区满了，就会触发Full GC，Full GC是非常耗时的，设立s区的一个目的就是在Eden区和老年代中增加一个缓冲池，放一些“年纪不够老”的对象，增加垃圾回收性能
问题3：触发GC的流程
- 答：GC分为 minor GC 和Full G

minor GC： 新生对象都会放在eden区，当eden区放满，触发minor gc，将eden区还存活的对象age+1放到s0区，然后清空 enden区和s1区，然后继续。。eden区再满时，将eden还存活的对象和s1区还存活的对象age+1，然后放到s0区，再清空eden区和s`。。。（期间age>15的对象就会被放入到老年代，大对象（占from（to）区内存空间的一半以上都算大对象）也会放入到老年代）就这样周而复始，直至某一次 enden区的对象+ to/from区的对象移到 from/to区时，放不下了，就会把对象都放入到老年代。清空新生代，继续执行上述。

Full GC：最终老年代越放越多，直至放不下，就会触发full gc。

minor GC的S0和S1区的设置为了解决复制算法的碎片化

所以，通过上述会发现，频繁造成full gc的原因是因为：新生代区总是放不下，频繁地向老年代放对象导致的，所以如果我们增大新生代区的内存空间，新生代区的空间大到基本能够支撑业务线程执行完后的下一个周期的时间间隔（（因为线程执行完，局部变量会立刻被回收，而该线程中对象并不会立刻回收，而是要等到一次 gc，gc发现这些对象被root引用，就视为垃圾才回收）。该回收的对象也基本都会在minor gc 就给回收掉了，所以很少有对象能够放到老年代，自然也会导致full gc的频率下降！！。

所以解决的办法是：把新生代和老年代默认的比例1:2 改大一点，根据业务线程评估会new对象，基本是按一个对象1kb累计，最后评估的结果再放大10-1000倍，就是一次线程执行完一次应该占用的内存，在知道新生代和老年代占空间的大小下，就可以粗略算出minor gc 和 full gc 触发的频率。

具体场景：假如堆的空间有3G,则新生代1G,老年代1G,enden取800M,to 区100M,from区 100M，假如订单系统，每秒会有400个请求，一个订单系统线程可能创建10kb的空间占用，所以每秒会在eden区生成：400*10kb/1024~=4M, 为了避免没考虑到的对象，所以放大10倍，所以每秒有 40M存放到enden区，所以大约 800M/40M=20s 就会造成一次 minor gc ，或者说20s后这些占40M空间的基本会被gc回收掉（因为一两秒之后这40M很有可能变成垃圾了，因为线程（不是复杂的业务线程基本都能很看执行结束）可能已经结束了，属于该线程的局部变量已经被回收了，但该线程的创建的对象也失去了root引用，就等gc执行时把他给回收了，所以这40M的（存储对象的空间）就应该被回收了）但有可能个别线程因某个原因执行的稍稍慢一点点，eden回收了大部分的空间，如19个40M,但还有一个40M正在被线程持有，这个40M就该移动到to/from区了。但40M （可能大于to/from区的一半则）视为大对象，就会放入到了老年代。频繁导致full gc的原因就在这里！！

总结：几分钟、几小时就触发了full gc。原因是因为：业务线程引用的对象所占的空间大于或等于了 s0/s1区的一半，容易被直接放入老年代。

解决方法：调整新生代、老年代的比例，以及 eden 、s0、s1区的比例！。

②方法区（元空间）

存放类编译后的信息，如静态变量、类的属性

③程序计算器

线程私有
用于控制线程执行字节码的行号指示器，告诉cpu下一条执行该执行谁了，由字节码执行器来负责修改其内容。（因为java是多线程，执行到一半cpu可能干其他事情去了，等cpu有资源时，要根据程序计算器继续干接下来的工作）

④虚拟机栈

详细可参考：虚拟机栈的栈帧都包含些什么？_yozzs的博客-CSDN博客_虚拟机栈存放什么数据

描述jvm执行方法的内存模型，每次调用一个函数都对应一个 “栈帧”压入虚拟机栈，函数调用结束又表示，该函数调用完成。
帧栈，主要是函数的相关信息：包含了

① 局部变量表（因为局部变量属于函数嘛，都是临时工要在这里登机一下咯）

② 操作数栈（从局部变量表里取某变量，在这里进行加减乘除的运算）

③ 动态链接（理解不够深刻）：将符号变量替换成直接引用

④ 方法出口.（计算完结果把结果返回到上一个压入栈的帧的地址，也可能计算途中遇到异常，所以可能返回异常出口的地址、或者方法正常执行完成的返回的地址）。

⑤本地方法栈

和虚拟机栈几乎一样，只不过这里调用的都是 native方法都是执行c++或者c方法。

(135条消息) 五位卷王 | 总结的十道 JVM 面试真题！（建议收藏）_hzbooks的博客-CSDN博客

11、json转java对象技巧

使用alibaba的fastjson 即可：


 
JSONbject.toJavaObject(XXX,XXXX.class);//参数1是JSON对象  参数2是要封装进去的对象类文件


//单独使用
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
List<XXXXX> rootProducts = objectMapper.readValue(data, new TypeReference<>() {});

个人倾向使用fastJson但的确存在不少未知bug，踩坑到哭

使用jackjson的工具类（推荐使用）

fastjson的坑：is开头接收boolean类型的会解析不到！

（对data好像也解析不到，未测试，但见有此现象）


@Slf4j
public class JsonUtil {
 private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
static{
//对不存在的数据字段 解析不到不报错
 objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
}
 public static String getValue(String content, String key) {
        String value = "";
        try {
            JsonNode jsonNode = OBJECT_MAPPER.readTree(content);
            jsonNode = jsonNode.get(key);
            if (Objects.nonNull(jsonNode)) {
                value = jsonNode.toString();
            }
        } catch (Exception e) {
            log.error("get value from json failed! key[" + key + "].", e);
        }
 
        return value;
    }
 
    /**
     * 对象转json字符串
     *
     * @param object
     * @return
     */
    public static String convertJson(Object object) {
        try {
            return OBJECT_MAPPER.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            log.error("get json from value failed! value[" + object.toString() + "].");
            return "";
        }
    }
 
 
    /**
     * @param content json字符串
     * @param valueType class
     * @param <T> 泛型
     * @return 该类型
     */
    public static <T> T convertObject(String content, Class<T> valueType) {
        try {
            return OBJECT_MAPPER.readValue(content,valueType);
        } catch (JsonProcessingException e) {
            log.error("get object from json failed! json[" + content + "].",e);
            return null;
        }
    }
}

使用方法：

json转对象

通过key获取value

注：有时候要解析比较特别的json字符串：如下：（即：带转义的字符串型json）

"{\"platform_id\":\"10000\",\"site_id\":\"20000\",\"store_id\":30000,\"datas\":[{\"product\":{\"product_id\":\"5203225\",\"app_id\":\"10000\",\"product_code\":\"17288278\",\"name\":\"hbdtgsbhg\",\"description\":\"dgfsbhfds\",\"category_id\":\"3105\",\"front_category_id\":null,\"price\":\"24.99\",\"msrp\":\"66.99\",\"middle_east_price\":\"30.99\",\"id\":\"5203225\",\"operator_id\":0,\"icon\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993cf2ce6e2.jpg\",\"group_id\":2065087,\"image_id\":3683062},\"skus\":[{\"id\":19700443,\"product_id\":\"5203225\",\"code\":\"CN-1075-5203225-19700443\",\"sku_code\":1728827801,\"price\":\"24.99\",\"msrp\":\"66.99\",\"icon\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993cf2ce6e2.jpg\",\"image_id\":3683062,\"group_id\":2065087},{\"id\":19700444,\"product_id\":\"5203225\",\"code\":\"CN-1075-5203225-19700444\",\"sku_code\":1728827802,\"price\":\"24.99\",\"msrp\":\"66.99\",\"icon\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993cf2ce6e2.jpg\",\"image_id\":3683062,\"group_id\":2065087},{\"id\":19700445,\"product_id\":\"5203225\",\"code\":\"CN-1075-5203225-19700445\",\"sku_code\":1728827803,\"price\":\"24.99\",\"msrp\":\"66.99\",\"icon\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993d1ad6730.jpg\",\"image_id\":3683066,\"group_id\":2065087},{\"id\":19700446,\"product_id\":\"5203225\",\"code\":\"CN-1075-5203225-19700446\",\"sku_code\":1728827804,\"price\":\"24.99\",\"msrp\":\"66.99\",\"icon\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993d1ad6730.jpg\",\"image_id\":3683066,\"group_id\":2065087}],\"skuApp\":{\"1728827801\":{\"app_id\":\"10000\",\"sku_id\":19700443,\"sku_code\":1728827801,\"product_id\":\"5203225\",\"product_code\":\"17288278\",\"status\":2,\"color_scheme\":\"Beige\",\"created_at\":\"2020-10-28 11:24:53\"},\"1728827802\":{\"app_id\":\"10000\",\"sku_id\":19700444,\"sku_code\":1728827802,\"product_id\":\"5203225\",\"product_code\":\"17288278\",\"status\":2,\"color_scheme\":\"Beige\",\"created_at\":\"2020-10-28 11:24:53\"},\"1728827803\":{\"app_id\":\"10000\",\"sku_id\":19700445,\"sku_code\":1728827803,\"product_id\":\"5203225\",\"product_code\":\"17288278\",\"status\":2,\"color_scheme\":\"Grey\",\"created_at\":\"2020-10-28 11:24:53\"},\"1728827804\":{\"app_id\":\"10000\",\"sku_id\":19700446,\"sku_code\":1728827804,\"product_id\":\"5203225\",\"product_code\":\"17288278\",\"status\":2,\"color_scheme\":\"Grey\",\"created_at\":\"2020-10-28 11:24:53\"}},\"product_code\":\"17288278\",\"platform_id\":\"10000\",\"site_id\":\"20000\",\"store_id\":30000,\"translation\":[{\"id\":1244908,\"app_id\":10000,\"product_id\":5203225,\"product_code\":17288278,\"name\":\"hbdtgsbhg\",\"description\":\"dgfsbhfds\",\"language\":\"Russian\",\"status\":4,\"user_id\":0,\"created_at\":\"2020-10-28 11:25:16\",\"updated_at\":\"2020-10-28 11:25:16\"},{\"id\":1244907,\"app_id\":10000,\"product_id\":5203225,\"product_code\":17288278,\"name\":\"hbdtgsbhg\",\"description\":\"dgfsbhfds\",\"language\":\"Swedish\",\"status\":4,\"user_id\":0,\"created_at\":\"2020-10-28 11:25:13\",\"updated_at\":\"2020-10-28 11:25:13\"},{\"id\":1244906,\"app_id\":10000,\"product_id\":5203225,\"product_code\":17288278,\"name\":\"hbdtgsbhg\",\"description\":\"dgfsbhfds\",\"language\":\"Dutch\",\"status\":4,\"user_id\":0,\"created_at\":\"2020-10-28 11:25:11\",\"updated_at\":\"2020-10-28 11:25:11\"},{\"id\":1244905,\"app_id\":10000,\"product_id\":5203225,\"product_code\":17288278,\"name\":\"hbdtgsbhg\",\"description\":\"dgfsbhfds\",\"language\":\"Portugal\",\"status\":4,\"user_id\":0,\"created_at\":\"2020-10-28 11:25:09\",\"updated_at\":\"2020-10-28 11:25:09\"},{\"id\":1244904,\"app_id\":10000,\"product_id\":5203225,\"product_code\":17288278,\"name\":\"hbdtgsbhg\",\"description\":\"dgfsbhfds\",\"language\":\"ChineseTraditional\",\"status\":4,\"user_id\":0,\"created_at\":\"2020-10-28 11:25:07\",\"updated_at\":\"2020-10-28 11:25:07\"},{\"id\":1244903,\"app_id\":10000,\"product_id\":5203225,\"product_code\":17288278,\"name\":\"hbdtgsbhg\",\"description\":\"dgfsbhfds\",\"language\":\"German\",\"status\":4,\"user_id\":0,\"created_at\":\"2020-10-28 11:25:04\",\"updated_at\":\"2020-10-28 11:25:04\"},{\"id\":1244902,\"app_id\":10000,\"product_id\":5203225,\"product_code\":17288278,\"name\":\"hbdtgsbhg\",\"description\":\"dgfsbhfds\",\"language\":\"Italian\",\"status\":4,\"user_id\":0,\"created_at\":\"2020-10-28 11:25:02\",\"updated_at\":\"2020-10-28 11:25:02\"},{\"id\":1244901,\"app_id\":10000,\"product_id\":5203225,\"product_code\":17288278,\"name\":\"hbdtgsbhg\",\"description\":\"dgfsbhfds\",\"language\":\"French\",\"status\":4,\"user_id\":0,\"created_at\":\"2020-10-28 11:25:00\",\"updated_at\":\"2020-10-28 11:25:00\"},{\"id\":1244900,\"app_id\":10000,\"product_id\":5203225,\"product_code\":17288278,\"name\":\"hbdtgsbhg\",\"description\":\"dgfsbhfds\",\"language\":\"Spanish\",\"status\":4,\"user_id\":0,\"created_at\":\"2020-10-28 11:24:58\",\"updated_at\":\"2020-10-28 11:24:58\"},{\"id\":1244899,\"app_id\":10000,\"product_id\":5203225,\"product_code\":17288278,\"name\":\"hbdtgsbhg\",\"description\":\"dgfsbhfds\",\"language\":\"Arabic\",\"status\":4,\"user_id\":0,\"created_at\":\"2020-10-28 11:24:55\",\"updated_at\":\"2020-10-28 11:24:55\"}],\"operator_id\":0,\"id\":\"5203225\",\"sku_images\":[{\"product_id\":\"5203225\",\"sku_id\":19700443,\"src\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993cf087b8e.jpg\",\"sort\":0,\"template_no\":1,\"scale_type\":1,\"group_id\":2065087,\"image_id\":3683061},{\"product_id\":\"5203225\",\"sku_id\":19700443,\"src\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993cf2ce6e2.jpg\",\"sort\":1,\"template_no\":1,\"scale_type\":1,\"group_id\":2065087,\"image_id\":3683062},{\"product_id\":\"5203225\",\"sku_id\":19700443,\"src\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993cf394927.jpg\",\"sort\":2,\"template_no\":1,\"scale_type\":1,\"group_id\":2065087,\"image_id\":3683063},{\"product_id\":\"5203225\",\"sku_id\":19700443,\"src\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993cf523de2.jpg\",\"sort\":3,\"template_no\":1,\"scale_type\":1,\"group_id\":2065087,\"image_id\":3683064},{\"product_id\":\"5203225\",\"sku_id\":19700444,\"src\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993cf087b8e.jpg\",\"sort\":0,\"template_no\":1,\"scale_type\":1,\"group_id\":2065087,\"image_id\":3683061},{\"product_id\":\"5203225\",\"sku_id\":19700444,\"src\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993cf2ce6e2.jpg\",\"sort\":1,\"template_no\":1,\"scale_type\":1,\"group_id\":2065087,\"image_id\":3683062},{\"product_id\":\"5203225\",\"sku_id\":19700444,\"src\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993cf394927.jpg\",\"sort\":2,\"template_no\":1,\"scale_type\":1,\"group_id\":2065087,\"image_id\":3683063},{\"product_id\":\"5203225\",\"sku_id\":19700444,\"src\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993cf523de2.jpg\",\"sort\":3,\"template_no\":1,\"scale_type\":1,\"group_id\":2065087,\"image_id\":3683064},{\"product_id\":\"5203225\",\"sku_id\":19700445,\"src\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993d1999cc5.jpg\",\"sort\":0,\"template_no\":1,\"scale_type\":1,\"group_id\":2065087,\"image_id\":3683065},{\"product_id\":\"5203225\",\"sku_id\":19700445,\"src\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993d1ad6730.jpg\",\"sort\":1,\"template_no\":1,\"scale_type\":1,\"group_id\":2065087,\"image_id\":3683066},{\"product_id\":\"5203225\",\"sku_id\":19700445,\"src\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993d1d3a24b.jpg\",\"sort\":2,\"template_no\":1,\"scale_type\":1,\"group_id\":2065087,\"image_id\":3683067},{\"product_id\":\"5203225\",\"sku_id\":19700445,\"src\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993d1e3dc97.jpg\",\"sort\":3,\"template_no\":1,\"scale_type\":1,\"group_id\":2065087,\"image_id\":3683068},{\"product_id\":\"5203225\",\"sku_id\":19700446,\"src\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993d1999cc5.jpg\",\"sort\":0,\"template_no\":1,\"scale_type\":1,\"group_id\":2065087,\"image_id\":3683065},{\"product_id\":\"5203225\",\"sku_id\":19700446,\"src\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993d1ad6730.jpg\",\"sort\":1,\"template_no\":1,\"scale_type\":1,\"group_id\":2065087,\"image_id\":3683066},{\"product_id\":\"5203225\",\"sku_id\":19700446,\"src\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993d1d3a24b.jpg\",\"sort\":2,\"template_no\":1,\"scale_type\":1,\"group_id\":2065087,\"image_id\":3683067},{\"product_id\":\"5203225\",\"sku_id\":19700446,\"src\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993d1e3dc97.jpg\",\"sort\":3,\"template_no\":1,\"scale_type\":1,\"group_id\":2065087,\"image_id\":3683068}],\"product_icons\":[{\"product_id\":\"5203225\",\"scale_type\":1,\"template_no\":1,\"icon\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993cf2ce6e2.jpg\",\"group_id\":2065087,\"image_id\":3683062}],\"product_sku_icons\":[{\"sku_id\":19700443,\"sku_code\":1728827801,\"product_id\":\"5203225\",\"template_no\":1,\"icon\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993cf2ce6e2.jpg\",\"group_id\":2065087,\"image_id\":3683062},{\"sku_id\":19700444,\"sku_code\":1728827802,\"product_id\":\"5203225\",\"template_no\":1,\"icon\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993cf2ce6e2.jpg\",\"group_id\":2065087,\"image_id\":3683062},{\"sku_id\":19700445,\"sku_code\":1728827803,\"product_id\":\"5203225\",\"template_no\":1,\"icon\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993d1ad6730.jpg\",\"group_id\":2065087,\"image_id\":3683066},{\"sku_id\":19700446,\"sku_code\":1728827804,\"product_id\":\"5203225\",\"template_no\":1,\"icon\":\"http:\\\/\\\/aaawebstatic.s3.us-west-2.amazonaws.com\\\/origin\\\/product\\\/000000000000\\\/5f993d1ad6730.jpg\",\"group_id\":2065087,\"image_id\":3683066}]}]}"

扩展：有时候想直接提取json中某个字段对应的value，可以使用以下工具类


import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
 
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
 
public class JsonUtils {
 
    public static List<String> getFieldValues(String json, String fieldName) throws IOException {
        ObjectMapper mapper = new ObjectMapper();
        JsonNode rootNode = mapper.readTree(json);
        List<String> values = new ArrayList<>();
        getFieldValues(rootNode, fieldName, values);
        return values;
    }
 
    public static void getFieldValues(JsonNode node, String fieldName, List<String> values, String dateFormat) {
        if (node.isObject()) {
            node.fields().forEachRemaining(entry -> getFieldValues(entry.getValue(), fieldName, values, dateFormat));
        } else if (node.isArray()) {
            node.elements().forEachRemaining(element -> getFieldValues(element, fieldName, values, dateFormat));
        } else if (node.has(fieldName)) {
            String fieldValue = node.get(fieldName).asText();
            if (dateFormat != null && !dateFormat.isEmpty()) {
                LocalDateTime dateTime = LocalDateTime.parse(fieldValue, DateTimeFormatter.ISO_DATE_TIME);
                fieldValue = dateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
            }
            values.add(fieldValue);
        }
    }
}
 
 
------------------------------------
使用方法：
String jsonString = "{\"users\":[{\"id\":1,\"name\":\"Alice\"},{\"id\":2,\"name\":\"Bob\"},{\"id\":3,\"name\":\"Charlie\"}]}";
List<String> names = JsonUtils.getFieldValues(jsonString, "name");
System.out.println(names); //[Alice, Bob, Charlie]

12、加空字符串的妙用 "对象"+""

当你使用对象.toString() 方法时，最好使用 +"" 方式代替，因为对象有可能是null，执行时会导致空指针异常。但是null对象+字符串=“null” 所以还要replaeAll("null","");

13、输出数组技巧。

把数组放入到 ArrayList中

14、界面点击按钮不生效，往往是js文件加载错，文件名写错导致的

虽然这个问题很low 但是使用idea，有时候使用Refaotr导致改文件名会不小心改动了其他的地方。

浏览器控制台：Failed to load resouce:the XXX.js server responesd with a status of 404 即战斗资源。

15、项目本地访问页面正常，部署到服务器上访问不到。

场景：使用springmvc查询数据并返回页面。本地运行正常，但在服务器部署出现如下错误：

报错日志：Could not resolve view with name 'XXXX' in servlet with name 'springmvc'

思路：发现 return "XXXX" 是 XXXX和实际的页面文件名称不一样，自然是找不到页面的了，可是为什么本地可以而服务器却不可以？难道是运行在tomcat上的项目 spring的视图解析器不区分大小写，而运行在liberty上区分大小写？

原因：只是指定servlet相对路径下的视图文件。所以是否敏感取决于servlet对文件名大小写是否敏感，或者说归根到底，取决于操作系统对文件名大小写是否敏感。

总结：无论是什么，最好return的页面和实际页面名称保持一致。莫粗心，慎用idea的查找替换。

16、应用部署 tomcat部署和Liberty部署

1、tomcat部署，老生常谈，把应用程序的war包放到tomcat下的 webapps，然后去上级目录的bin目录下，运行 shutdown.sh 或startup.sh即可对应用进行停、启操作

2、（IBM公司开发的）liberty部署。特点：轻量级（占内存少）、动态（更新配置文件重启项目，自己会更新）将war包放到 XXXXX/dropins 目录下即可，然后去 XXX/servers 下执行:（发现在任意目录下也可以执行下面语句，可能公司的服务器配了全局变量）


server start war包名称   //不带后缀 启动应用
server stop war包名称   //不带后缀  关闭应用

参考文章：liberty | 在IDEA整合Springboot与IBM liberty_Eshare分享-CSDN博客

17、数据库查询和 hibernate查询的条数一样，但部分行不一样。

场景：测试测试查询条件，我在数据库里造了几条不同的数据，只改动了部分列的值。

现象：数据库查的条数和开发的系统查的条数一致，但内容却不一致。

原因：查询的该表未设置主键，而hibernate的实体类上指定了主键。于是在查询时候，hibernate会认为相同 id值的就是同一个对象，造成行覆盖，出现了：明明数据库有这条数据，但在java查询查出来的还是却没有这条数据.

18、linux上查找应用程序所在的文件夹

基本思路：找到应用程序的pid，再根据pid找到文件夹

方法1：根据应用端口号查找pid，在根据pid查找位置


//步骤1： 根据端口号找到pid
netstat -nptl |grep 9088   //快速记忆法   nptl  你怕他了
 
会输出：tcp6 0 0 0::9088 :::* LISTEN 29998/java 
 
//发现是 9088的端口 是由 pid为 29998的 进程在占用
 
//步骤2：根据pid找到 进程所在的目录  linux会为每个进程创建一个文件夹 在/proc目录下 pid作为文件夹名
 
cd /proc/29998
ls -al
会输出： 其中有：“cwd -> /webapps/wlp/usr/servers/ofp "
所以进程是在 /webapps/wlp/usr/servers/ofp 目录下

方法二：根据 ps命令查找pid，再根据pid查找位置。


ps -ef |grep ofp    
//输出 几行有 ofp的 进行信息， 第一列就是pid

方法三：top -c命令

top -c  // -c是显示 路径名称

19、Idea在debug模式下,停止当前函数(不执行断点后的代码)

场景:断点调试查看某个功能时，有时候只是为了看流程，但当其执行到操作数据库时，并不想真的去提交数据到数据库，这时候要么终止项目，再重启项目（效率低），要么使用这个方法：

参考博客：

Idea在debug模式下,直接停止程序(不执行断点后的代码)_云别-CSDN博客_idea结束debug

20、相同项目代码，运行在两个环境，一个正常执行，一个等待很久才报错

关键词：断点调试执行要等很久

场景：拷贝项目到本地，运行发现断点执行某句语句时，要等很久。

原因：一般情况是最后报超时错误。（多翻一下报错日志，看看含time、socket字样），发现是请求超时等问题，查看我这项目也没什么请求的啊。报错是执行查询hbase时报错的。

解决：项目使用的数据库地址是映射的。即在host文件中配置了具体的ip地址，而我的电脑host没有那个映射自然查询不到数据库导致的报错。坑爹项目！

21、tomcat部署后新war包后，重启后代码似乎没生效

（关键字：部署war包，像没部署一样、tomcat）

场景：新打的war包，修复了bug。部署到测试环境下，但修复bug仍就出现，本地却是好的。

原因：此刻tomcat正在运行旧的war包，这时新的war包放到tomcat时，我们会以为覆盖旧的war包。再重启tomcat就可以运行最新的war包了。但事实上是：当你把新war包覆盖旧war包的时候，这时tomcat会解压旧的war包，生成 rcp文件夹（我的是rcp.war）。每次启动tomcat都运行的是 rcp文件夹的代码，即：运行的旧的代码。

解决：删除 tomcat解压生成的同名项目文件夹，即删除 rcp文件夹（我的项目名叫rcp）。再重启tomcat即可。

总结：先停服务(shutdown.sh)，再更新war包，再启动服务（start.sh）.

文章参考：Tomcat 何时解压war包 - fatsnake - 博客园

22、java解析json中某个字段

方法1：


json字符串： {"age":"10","name":"李四","address"：{"area1":"萧山区","area2":"杭州市"} }
 
 
JSONObject jsonParam =JSONObject.parseObject(json的字符串);
 
//getString()方法 只解析 当前一层的 key：value。 
String  age = jsonParm.getString("age");  //age=10
String  address= jsonParm.getString("address");  //address={"area1":"萧山区","area2":"杭州市"}
 
T object = JSONobject.toHavaObject(json字符串,T.class); //解析出T类 参数自动匹对  
 
 
注：这些方法依赖fastjson包

方法2：（推荐）但需要引入


         <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.7.4</version>
        </dependency>


import cn.hutool.json.JSONObject;
。。。。
 
public static void main(String[] args) {
        JSONObject jsonObject = new JSONObject("{\"name\":\"李四\"}");
        Object name = jsonObject.get("name");
        System.out.println(name); //输出李四
    }

23、SpringBoot的启动原理

知识点学习：

1、为什么使用springBoot？（以web项目为例）

①简化配置。否则要在web.xml中注册SpringMVC的DispatcherServlet，拦截器、过滤器等

②统一管理各个组件依赖的jar包。手动维护免费、费事。

所以SpringBoot在此基础上，整合了一套快速开发的工具包。开箱即用，一行代码就能启动。

2、SpringBoot场景启动器starter。不同场景有对应的启动器，那么他的作用是什么呢？

starter的实现逻辑主要由两个基本部分组成：

xxxAutoConfiguration：自动配置类，不同场景下，自动配置类的内容就不一样。对某个场景下需要使用到的一些组件进行自动注入，并利用xxxProperties类来进行组件相关配置。如：spring-boot-starter-模块名

xxxProperties：某个场景下所有可配置属性的集成，在配置文件中配置可以进行属性值的覆盖。

所以，引入starter后，springBoot就会在启动的时候帮我们完成相关的：自动配置、自动导入

3、SpringBoot的启动原理？

首先，查看SpringBootApplication注解结构：

SpringBoot在启动的时候从类路径下的（所有的）META-INF/spring.factories中获取EnableAutoConfiguration指定的所有自动配置类的全限定类名
将这些自动配置类导入容器，自动配置类就生效，帮我们进行自动配置工作；
整个J2EE的整体解决方案和自动配置都在spring-boot-autoconfigure的jar包中；
它会给容器中导入非常多的自动配置类（xxxAutoConfiguration）, 就是给容器中导入这个场景需要的所有组件，并配置好这些组件；
有了自动配置类，免去了我们手动编写配置注入功能组件等的工作

文章参考：图文并茂，Spring Boot Starter 万字详解！还有谁不会？

精通Spring？请吃我一狗腿！【文末送书】

扩展：@import注解，顾名思义，导入，即把类加入Spring IOC容器。
有多种方式能让类加IOC容器管理，如@Bean、@Component等，@Import是另外一种方式，更加快捷。

@Import支持三种方式
1.带有@Configuration的配置类(4.2 版本之前只可以导入配置类，4.2版本之后也可以导入普通类) 加上@Configuration是为了能让Spring 扫描到这个类
2.ImportSelector 的实现
3.ImportBeanDefinitionRegistrar 的实现

实现自己的的start：如：my-spring-boot-start

①创建项目，父pom依赖 springboot-boot-start

②创建XXXProperties 配置参数自动封装成对象的类，如叫 MyProperties.java

可能使用到的注解有：@ConfigurationProperties(prefix = "XXX.YYY")

③创建XXXAutoConfiguration,如叫：MyAutoConfiguration

注1)需将此类注入到spring中：因此使用：@Configuration

注2）使用配置文件： @EnableConfigurationProperties(MyAutoConfiguration.class)

注3）（@EnableConfigurationProperties，本质就是@Import注解）

注4）通常会在此类中要注入的bean，但会依据@ConditionalOnMissingBean判断是否要注入，如果spring容器中已经存在bean了，这也是自动注入的关键！

④在resources/META-INF/spring.factories中配置


org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
我们的类路径

24、mybatis#{}和${}的区别

两者的区别

#{}：使用的是预编译，对应JBDC中的PreparedStatement，井好！
${}：mybatis不会修改或者转义字符换，直接输出变量值

扩展：

坑：有时候偷懒直接传参，如：String ids ="1,2,3" 字符串作为参数在xml中拼接xsql时

select * from XXX_table in （#{ids}）而没使用foreach进行拼接。

结果：不报错，但返回的数据只有一条

总结：偷懒的写法，日志打印只有一个？常规的写法，日志打印？？？ 3个占位符

文章参考：#{}和${}的区别_lt_zl的博客-CSDN博客

25、编写单元测试，@Autowired注入的对象为null问题。

场景：自己编写了一个查询的query()函数（该函数所在类名：A），想在测试类中调用该函数，因此，我写的测试类代码如下：


@RunWitg(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(class= 启动类.class)
 
public class MyTest{
    
    //能注入成功，未运行时，一般会提示报错说找不到bean，不用管，运行后就不报错了
    @Autowired
    private QueryUser queryUser;
    
    @Test
    public void test(){
        /*getUser方法 中 使用了注入sqlsession对象，这个是有值的*/
        User user = queryUser.getUser();
    }
 
     @Test
    public void test1(){
        QueryUser  queryUser1= new QueryUser();
        /*getUser方法 中 使用了注入sqlsession对象，这个是有null的*/
        User user = queryUser1.getUser();
    }
}

对比 test和test1 可以发现，自己创建的对象queryUser1中注入其他对象，但事实上并没注入成功？为什么呢？

个人觉得，自己创建的对象不受spring容器控制，和spring容器是两回事，所该对象引用的一些spring的对象，自然注入不进来。（该观点可能错误，未看源码的猜测）。

解决方法：使用自动注入的对象，可以使用spring容器中的主动注入对象。（即上述代码中test方法的使用）。

后续更新：

步骤1：创建一个基类。子类去继承这个基类，就可以了


import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
 
@SpringBootTest
@RunWith(SpringRunner.class)
public class BaseTests {
 
}

步骤2：


package com.11.search.service;
 
 
import com.11.search.BaseTests;
import com.11.search.entity.ProductIndexEs;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
 
//继承基类 顺便写
public class myServiceTest extends BaseTests {
    @Autowired
    ElasticsearchRestTemplate elasticsearchRestTemplate;
 
    @Test
    public  void ss(){
        NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
        builder.withQuery(QueryBuilders.matchAllQuery());
        NativeSearchQuery build = builder.build();
        SearchHits<ProductIndexEs> search = elasticsearchRestTemplate.search(build, ProductIndexEs.class);
        System.out.println("");
    }
 
}

扩展注意知识点：

①子类继承父类BaseTests 的测试类必需要是public类
②单元测试时开启事务（默认开启回滚），执行成功，但数据库并未改增删。（防止测试污染数据库）

如果想让单元测试插入数据库则需要加上@Roolback（false），如下：


    @Test
    @Transactional(rollbackFor = Exception.class)
    @Rollback(false)  //不写的话，单元测试成功后也默认回滚
   public  void test() {
        insertAll();
        quertList();
        System.out.println("hello");
    }

26、动态加载配置文件

运行中的项目，更新了配置文件，又不想重启，如何让程序自动更新加载这个文件呢？

首先，想到的是写个死循环，让这个线程一直去查看文件是否改变，改变则重新读取。但是浪费cpu资源啊。

个人想法（未实践）：使用观察者模式，A改变状态，通知B去读取配置文件。即：运行的程序比如预留了一个controller的requestMapping，如：htttp://ip/item/myselfequest。当我们更新完服务器上的配置文件后，在服务器上请求一下预留的那根请求。curl "htttp://ip/item/myselfeques",通知B去重新读取配置文件。也就是手动触发。

27、接口开发、其他系统的接口请求、postman请求可以，java请求有问题。

场景：开发稍大的系统，都会遇到 A服务器上的项目，调用B服务器上的项目。A如何像postman一样去调用呢？

解决：

方法1：使用 RestTemplate. 。常规方法

RestTemplate 用法详解_Lzc的博客-CSDN博客_resttemplate

ResrTemplate的默认请求头是：application/json

此方法：一般没什么问题，很方便，但有时候会因为请求头、协议一些问题卡壳。。。


package com.接口请求;
 
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import org.springframework.web.client.RestTemplate;
 
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
 
public class MyRestTemplete {
 
    public static void main(String[] args) throws IOException {
 
    RestTemplate restTemplate = new RestTemplate();
//
        String url = "http://localhost:8080/test1";
        Map<String,Object> map = new HashMap<>();
        map.put("name","张三");
       // Object object=  restTemplate.getForEntity(url,Object.class,map);
        Object object1=  restTemplate.postForObject(url,map,Object.class);
 
    }
 
 
}

文章参考：RestTemplate发送HTTP、HTTPS请求_JustryDeng-CSDN博客_resttemplate调用https接口

RestTemplate HttpMessageConverter报错的解决方案no suitable HttpMessageConverter - 未月廿三 - 博客园

此次记录一次使用RestTemplate发送 form-data的post请求：（其他几种方式没能成功）亲测可用。


public static XXX sendPostByFormData() {
 
        //1 创建请求对象
        RestTemplate restTemplate = new RestTemplate();
 
        //2 设置请求头信息
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
 
        //3 设置请求的参数
        MultiValueMap<String,String> params = new LinkedMultiValueMap<>(); //这里是导入 import org.springframework.util.LinkedMultiValueMap包下的
        params.add("name","张三");
 
        //4 将参数设置进 请求实体内
        HttpEntity<MultiValueMap<String,String>> httpEntity= new HttpEntity<>(params,headers);
 
        //5 发起请求,拿到请求的结果   注：此次 最好使用String.class接收，之后再使用fastJson进行解析。因为如果 返回的json对象中含 数组类型的，即使我们使用List<Object>接收，会接收不到值，细看会发现list的对象中的JSONObject对象不再是HashMap而是LinkedHashMap
        ResponseEntity<String> response = restTemplate.exchange("http://localhost:8080/test1", HttpMethod.POST,httpEntity,String.class);
        String strBody = response.getBody();
 
        //解析对象
        XXX  xxx = JSON.parseObject(strBody,XXX.class); //XXXX为某个对象类型
        return  xxx;
 
    }

失败的案例记录1：//请求返回200 ok，但参数解析失败


 public Object ss(){
 
        Map<String,Object> paramMap = new HashMap<>();
        paramMap.put("name","张三");
 
        RestTemplate restTemplate = new RestTemplate();
        String response =restTemplate.patchForObject("http://localhost:8080/test1",paramMap,String.class);
        System.out.println( response);//请求返回200 ok，但参数解析失败
        return response;
 
    }

//失败案例2

好文参考学习 SpringBoot的HttpMessageConverter使用（1）RestTemplate中的应用 - 简书

方法2： 用postman生成代码，贴到代码中，会像在postman上测的那样。

使用postman自动生成java代码。理论上postman能够请求成功的接口，通过自动生成就能拷贝在代码中请求成功。

1/3点击code按钮，

2/3选择编程语言：

3/3 自己的项目依赖okhttp的jar包


         <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>3.8.1</version>
        </dependency>

把代码贴到自己的项目中就ok了！（注：导包时，都选okhttp的包）

此方法，目测是凡是 postman可以做的，都可以使用java来做。

请求接口中踩的坑：

1、要确认别人提供的接口版本是否最新，别人家修改了url，你还在傻傻用上一个版本的url，出现postman请求没问题，自己却请求接口不存在、或者解析参数错误的这种。low坑

28、linux查看日志小技巧。

高效的查找命令，有助于快速有效定位问题。

grep命令

小技巧：有时候输出的日志密密麻麻，希望用颜色标识日志中匹配到的内容，方便聚焦。于是：
grep --color  "要查找的内容"  文件名           //注：而不是 -color
默认匹配到的是棕红色

全局配置，避免每次输入--color参数，自动给grep加颜色:
[root@home]#vim ~/.bashrc    //打开配置文件，添加 下面的语句
alias grep='grep --color'   //  以后输入grep 就相当于输入了 grep --color
//保存bashrc文件后，更新系统配置
[root@home]#source ~/.bashrc    


惯例使用的  ：
 
//查找 XXX.log的日志文件  只找 421723199606258699  的字符串
 
cat  XXX.log |  grep 421723199606258699  
 
 
比较好用的写法是：
//grep 要查找的内容  文件名
 
//如： 查找当前 logs目录下的 所有的log中含 421723199606258699  的日志
 
grep  421723199606258699 ./logs/*.log

有时候我们输入一个关键字出现好多信息，比如把前几天的日志也给查找出来了。这时候我们可以只要后面最新的几条就好：
grep  张三  my.log  | tail -n 2  //找到张三 并打印最后出现2次张三的行    

awk命令

场景：想要查看某条日志B，前面离A最近的某个特定日志A: 即 A日志，和B 日志两个字符串中间还隔着好多不需要的日志。

形如：（因为很多时候 B报错了，现在想看A传入的参数，所以B在错误的位置很好定位，但是A可能要翻很久）


//现在想获取 B 记录前的 A记录
log.info("A log....");
 
///中间还有很多 log.info
log.info("XXXX log....");
 
log.info("B log....");

那么可以使用命令:(基本思想，使用先入后出的思想，使用tac反向查找达到找最近出现的一行)


grep "B" /XXX/XXX/pathFile/XX.log   //定位B
 
//步骤1：定位B, 向前查找10000行（最好看一下处理一次的流程大概要输出多少日志，这个值就取多少，一般100000行应该能包含了）  并把这部分日志 导入 到 temp.txt 文件中
grep  -B 10000 "B" /XXX/XXX/pathFile/XX.log > temp.txt  
 
//步骤2： 使用tac命令，从某文件的最后一行开始输出
tac temp.txt | grep "A"

29、SpringBoot配置文件中的值读取、@values注解

场景：一般java取值从配置文件中取我们配好的值，但是避免有人误删了配置文件中的值，所以会在代码中也有默认值，如下写法：

即使配置文件和java中的值不一样，会先读取nacos里的，其次是配置文件里的，最后是默认值，如果没有则会报错。

30、开发心得、良好的习惯、易维护的代码。

抽取函数，传参最好不要传对象，而是传基本类型。参数超过4个传对象还是不错的

因为其他地方想调时，对象类型限制了，且因为函数内部有使用 XXX= 对象.属性这样的赋值，导致函数不能通用，所以如果参数不是很多的话，除了 controller层其他层传参最好使用基本类型的方式。

此方式会很大程度上解决，很多函数功能相似，但又无法适用当前开发需求的问题
对与查找的逻辑，最好使用java8 的stream，将其转化为 map的方式，提高查询效率，且方便越多

31、部署jar包应用的偷懒技巧。

执行jar命令：sh run.sh 即可启动


#脚本解释：     文件名可叫 run.sh
// 功能：自动将当前目录下的jar包 执行 java -jar XX.jar  并且吧 标准输出 和错误输出 重定向到黑洞
 
#!/bin/sh
 
 
# 获取当前目录
DIR='dirname $0'
 
#打开当前目录
cd $DIR
 
#执行java -jar XXX.jar    解释：把标准输出重定向到“黑洞”，还把错误输出2重定向到标准输出1
nohup  java -jar 'ls | grep jar'> /dev/null 2>&1 &
 
 
#将该应用的pid记录到tpid文件中 方便一会停止运行
echo $!>tpid
 
#提示用户启动成功
echo Start Success!

结束jar命令： sh stop.sh


#！/bin/bash
 
#cat tpid | xargs kill -9
 
pid='cat tpid'
 
while :
do
    rt='ps -ef | grep java | grep $pid'
    if[[ $rt =~$pid ]]
    then
        kill $pid
    else
        echo $pid is killed
        break;
    fi
done

32、idea必备快捷键

Ctrl+Alt+V 自动创建返回值及变量

Ctrl+Alt+ <-- 调回上次调用该函数的位置特别有效防止看代码时跳的晕头转向

33、guava学习和使用

guava技巧_飞花落雨的博客-CSDN博客

34、不常见，但很有用的注解

@JsonInclude(JsonInclude.Include.NON_NULL)  //标注在类头上，过滤json字段中为null的字段。

@Data //注解在类上, 为类提供读写属性, 此外还提供了 equals()、hashCode()、toString() 方法

@JsonProperty //此注解用于属性上，作用是把该属性的名称序列化为另外一个名称，1.前端传参数过来的时候，使用这个注解，可以获取到前端与注解中同名的属性  2。后端处理好结果后，返回给前端的属性名也不以实体类属性名为准，而以注解中的属性名为准


@Valid  //会去验证后面对象里面的每个属性，每个属性看是否符合要求，不符合时返回message
如：void myFunctuon(@Valid User user) {//todo}
 
而User中：
 
@Data
public class User {
    @NullNot(message = "用户名不能为空啊")
    private String username;
 }


  /**关键字，不引主，插入会报错，group在sql里是关键字，所以执行时会报错，
    看到日期打印的结果，框架本就提示出此错误可能是因为使用关键字导致的，
   起因： 数据库建表一般都是用引号引住的字段，所以可以见表成功，但是你的mybatis使用的时候没有引，
导致使用关键字报错，故，需要对有问题的字段进行 引用即可
*/
    @TableField("`group`")
    private String group;

注：如果前端传 http://XX/?name=1,2,3,4 后端类属性使用。private List<Stirng> name 即可自动转换为列表！（暂未亲测）

扩展：

注解Autowaired与 Resource的区别

@Autowired//默认按type注入（spring的注解）
@Qualifier("cusInfoService")//一般作为@Autowired()的修饰用

@Resource(name="cusInfoService")//默认按name注入，可以通过name和type属性进行选择性注入（javaee的注解）

推荐使用：@Resource，可以使代码更优雅，避免警告提示

@Autowired 与@Resource的区别（详细）_raymond_2580的博客-CSDN博客_@resource @autowired

35、PostMan使用技巧

场景：每次本地部署应用和远程部署一样，都要手动各创建一份请求，除了ip地址不同，其他路径和参数一模一样，如下：（原先自己都是在postman中创建两个文件夹，老粘贴复制，烦死。）


//本地请求
127.0.0.1:8080/user/operators
//远程请求
192.168.11.1:8080/user/operators

所以，有没有方法：把ip地址变成变量，切换“环境”就自动改变变量的值？postMan提供了！！

方法：

如果想创建环境，就选 No Environment 再点击小眼睛，就会弹出新窗口，添加，如下：

如果下修改环境，就选该环境，再点小眼睛。

详情参考：(65条消息) postman初级-1-环境变量：增、删、改、切换_花测试-CSDN博客_postman怎么删除环境变量

36、mysql 分页需要oder by 吗？需要

场景：按照mysql的数据结果，默认排序结果是 id列从小到大的排列。

select * from user limit 0，5 取前5条数据这是没有什么问题的，不用加order by

如果在sql语句中不指定order by排序条件，那么得到的结果集的排序顺序是与查询列有关的。因为不同的查询列可能会用到不同的索引，从而导致顺序不同。所以无论什么情况下，还是加上为好。

(65条消息) MySQL查询默认排序与order by排序_韩某的博客-CSDN博客_mysql查询结果默认排序

36、java CURD mysql时字段带"-",即短横问题

场景：java插入msyql时，失败，发现某字段带"-"

解决方法：加引号


原来是：
   @ApiModelProperty("繁体中文翻译")
    @TableField("zh-tw_name")
    public String zhtwName;
 
解决后是：加 ` //查询插入都不报错
   @ApiModelProperty("繁体中文翻译")
    @TableField("`zh-tw_name`")
    public String zhtwName;
 
切记 不是 加 '  //查询不报错了 插入报错
   @ApiModelProperty("繁体中文翻译")
    @TableField("'zh-tw_name'")
    public String zhtwName;

解决思路：发现打印的sql执行出错，看了没问题，去msql中查询却发现的确报错。所以加单引号

37、Git命令：

场景：开发时，一般分配的任务，自己在远程新开一个My分支，每次都在My分支上进行修改和提交，到任务都做完汇总的时候，再合并的主分支上。

或者自己先在本地创建本地分支，进行开发和修改，然后将本地推送到远程同名分支，也即是自己的这个分支推送到远程，开发完成再和主分支合并。

命令：


1，git clone  ssh://git@XXXX 克隆项目分支
 
2，git checkout master 切换到master分支
 
3，git checkout -b playBackQueue   创建playBackQueue分支并切换至这个分支，这个是本地分支
 
4，git branch 查看当前分支，*应该在playBackQueue分支上
 
5，git add .   添加修改
 
6，git status 查看工作区状态，即修改的文件有哪些
 
7，git commit -m"注释" 提交修改到当前分支
 
8，git push origin playBackQueue:playBackQueue把本地新建的分支推到远程分支，冒号前面是远程分支名，也可以与本地分支名不同
 
 
//9,10步骤 是将  playBackQueue 合并到master分支上
9，git checkout master 切换回master分支
 
10，git merge playBackQueue 合并自己的分支到master
 
11，浏览器查看是否提交上去了读代码
 
12，git push origin :playBackQueue 删除远程分支
 
或者git push origin --delete playBackQueue都可以实现删除远程分支
 
12，git branch -d playBackQueue 删除playBackQueue本地分支
 
13、将当前分支关联到指定分支
 git checkout -b gpf origin/gpf    # 新建本地分支gpf与远程gpf分支相关联

(68条消息) gitLab新建分支给远程分支提交代码_yana_balabala的博客-CSDN博客_gitlab提交新分支

上述命令遇到冲突就不好搞了，对应融合最好使用idea自带的。如果想将opensearch分支融合到masrer分支，则

①切换分支到master(如果本地已经有master分支，最好也切远程的，因为可以更新一下本地的master分支)

②git->merge

③执行融合，弹出来的下拉选项，如果没有opensearch 说明opensearch最新的代码已经融合到master分支了。如果有，那说明确实要融合一下最新的。

注：以上融合都是本地分支的融合，远程的分支还没融合这时候，虽然我并没有对mater分支进行修改，使用不了（因为提交也是没文件让你提交）。但是你这时候应该push一下到远程，push后才是真的推送到远程。

扩展：如果comit 且push到远程分支的话，现在想取消这次操作，则：

Revert Commit--》再push

（流程：先把本地的提交恢复到原来的，然后再提交恢复后的，如果第一次创建文件并push了一个文件，现在Revert Commit 变成了没有创建文件的状态，恢复后的其实就是把刚才的给删除了），再push远程（相当于告诉这个文件我删了你得删吧）

38、Collectors.toMap()、XX.stream().flatMap()的使用

Collectors.toMap()该函数的参数key、value均不能为空，否则空指针异常

codeMap = ValuesList.stream().filter(item->Objects.nonNull( item.getCode())).collect(Collectors.toMap(Values::getId,Values::getCode,(v1,v2) -> v1));

扩展：想要获取列表A中的列表B，将B中的所有集合放到C列表中


//存在空指针异常 i.getB()可能为空
List<B> c= products.stream().flatMap(i ->i.getB().stream()).collect(Collectors.toList());
 
//使用Optional.ofNullable(可能为空的对象) 防止A中的B 没有对象导致空指针异常
List<B> c= A.stream().flatMap(i ->Optional.ofNullable( i.getB()).orElseGet(ArrayList::new).stream()).collect(Collectors.toList());

注：toMap() 使用时，最好考虑到 key重复的情况。如：


//身份证号为key：value为name
XXX.toMap("persion身份证号"，persion.姓名,(v1,v2)->v2) //如果遇到重复的key 那就保留最新的value

代替：

XXX.toMap("persion身份证号"，persion.姓名)

39、myabtis报错：没有XX字段

场景：使用mybatis查询或插入时，myabatis报错，查无此列，核对了表结构、以及对应的实体发现都没问题也都没这个字段，那么这个字段哪里来的？？

解决：发现对应的实体继承了其他类，该类的私有字段也给继承回来了！！

所以：子类继承父类是继承了父类的所有！！包括private修饰的属性！！

40、mysql 表被锁

场景：一般发生在更新或者删除sql操作时。出现的情况是应用程序被kill -9 pid死的（正确操作：应该kill pid），更新sql语句时，结果java代码就卡在这里不动，好半天后报Lock wait timeout exceeded try restarting transaction。

java应用程序结束，已经开启的事务不一定结束！（未验证）

解释1：

原因：

锁表，是因为有个上一个事务A没有提交，现在来了事务B 要操作该资源（指：行表），导致B没法操作该资源，事务A又迟迟没了“动静”，出现锁表。该资源（指：行（如果是innoDB:可锁行、表）, 表(如果是MyIsAm，只可锁表)）

1.无索引情况下更新数据
begin;-- 开启事务
update tb_user set phone=‘15167891234’ where name=‘小花’;-- 修改，先别commit事务
再开一个窗口，直接运行命令：
update tb_user set phone=‘15167891234’ where name=“小明”;-- 发现一直卡着不能执行
但将第一个窗口的sql COMMIT之后，第二个窗口的更新语句就能执行了，说明在where条件后没索引的情况下锁表。

2.有索引情况下更新数据
create index index_name on tb_user(name);
加完索引之后继续按照1的步骤去执行，发现窗口2不会卡着了，立马执行了，说明没有锁表了，然后将相同的update语句在打开的2个窗口内执行（即：更新用一条），发现第2个窗口会一直卡着，说明在where条件后有索引的情况下锁行。

总结
在update/delete情况下，如果没有索引，会锁表，如果加了索引，就会锁行。但是其中过滤条件最好在主键索引情况下执行，因为过滤条件在非主键索引情况下，mysql会先锁住非主键索引，再锁定主键索引，如果此时恰好该行记录又根据主键索引更新，有可能也会发生冲突。
ps：数据库锁表时间一般为50s。

解释2：


//查看mysql自带的表中有哪些 事务
SELECT * FROM information_schema.INNODB_TRX;
 
//找到 trx_sql_thread_id  杀掉即可
kill  XXXX

如果怕以后再出现类似情况，在kill -9 XXX 时，让java持续知道自己被杀了，然后赶快回滚本次事务就行了。

解决办法：kill XXX 少用kill -9 XXX 前者会"有序退出程序"，后者直接嗝屁退出程序

kill 和 kill -9 是常用的命令，都可以用来杀死进程。那 kill 与 kill -9 有什么区别呢？

kill命令默认的信号就是15，也就是 kill -15 ,被称为优雅的退出。当使用kill -15时，系统会发送一个SIGTERM的信号给对应的程序。当程序接收到该信号后，具体要如何处理是自己可以决定的

注：其他博客都是 trx_state 是lock 才kil，而我遇到的是running状态，kill后发现也好了。

41、事务注解不生效：

场景：由于要数据解析MQ拉取的参数，我在service中创建了 A函数进行解析，然后调用带事务注解的B函数，B中有对数据库操作的 C,D函数。结果在B中执行完C，执行D时抛出异常，但数据没回滚。伪代码如下：


class  AAAA{
 
 
    /**A 调用带事务注解的B，此刻事务没开启，原因：事务注解基于动态代理，
    那么如果在类内部调用类内部的事务方法，这个调用事务方法的过程并不是通过代理对象来调用的，
而是直接通过this对象来调用方法，绕过的代理对象，肯定就是没有代理逻辑了
    */
    public void A(){
        //业务逻辑
        this.B();
    }
 
    @Transactional(rollbackFor = Exception.class)
    public void B(){
      this.C();//插入更新操作
       1/0;
      this.D();//插入更新操作
       
    }
 
    private void C(){//todo}
    private void D(){//todo}
    
}

解决： 将注解移到函数A头上即可。

扩展：

事务注解失效的原因：

①事务注解标注的当前函数的访问修饰符不是public

②在t同一个类中，函数A调用带有@Transactional标注的函数B方法。B是不会开启事务的（我的情况就是这个）

③捕获异常抛出事务却不回滚。

（我在类头上加事务注解，发现开启了事务，但是B中执行C后发生异常，数据并没有被回滚，原因是：如果方法中捕获异常后手动抛出异常，事务并没有回滚。）

解决办法：Spring事务默认支持RuntimeException异常，抛出的异常为RuntimeException异常及其子类异常事务均可生效，而我们日常常见的异常基本都继承自RuntimeException，所以无需指定异常类型事务也能生效。
但若手动抛出Exception异常，而Exception是RuntimeException的父类，会导致事务不生效。


@Transactional(rollbackFor = RuntimeException.class) 
//默认，如果你抛出Exception 他是拦截不到的 所以要么你 抛出 RuntimeException 要么 你这里写 rollbackFor= Exception.class

可是Exception是包含了 RuntimeException的啊，不知道为什么！

但是，下面的代码标记在方法上，是可以拦截检查和不可检查的异常的！！
@Transactional(rollbackFor = Exception.class)
总结：最好加在方法上，加类头上好像拦截不了运行时的异常（不可检查的异常）

小扩充：Exception分：可检查的（如I/O异常）、和不可检查的（如空指针异常，即根据运行的结果有不可预期的可能）。

(73条消息) @Transactional注解不起作用解决办法及原理分析_一撸向北的博客-CSDN博客_transactional注解失效

Spring事务不生效原因及解决方案_spring 事务失效_冰糖码奇朵的博客-CSDN博客

扩展：全局异常

springBoot中提供了全局异常的拦截处理。定义全局拦截方法，在类头上标记注解：

@RestControllerAdvice

代码如下：


 
 
import com.XX.product.config.MybatisPlusConfig;
import com.XX.product.model.common.ResponseDTO;
import com.XX.product.exception.ProductServiceException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.validation.BindException;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestControllerAdvice;
 
import javax.validation.ConstraintViolation;
import javax.validation.ConstraintViolationException;
import javax.validation.ValidationException;
import java.util.List;
import java.util.Set;
 
 
@Slf4j
@RestControllerAdvice
public class GlobalExceptionHandler {
 
    @ExceptionHandler(Exception.class)
    @ResponseStatus(HttpStatus.OK)
    protected <T> ResponseDTO<T> handleInternalException(Exception e) {
        String errCode;
        StringBuilder message = new StringBuilder();
        if (e instanceof ValidationException) {
            // 参数校验报错
            errCode = 50001;
            ConstraintViolationException exs = (ConstraintViolationException) e;
            Set<ConstraintViolation<?>> violations = exs.getConstraintViolations();
            for (ConstraintViolation<?> item : violations) {
                message.append(item.getMessage()).append(";");
            }
        } else if (e instanceof BindException) {
            // 参数绑定报错
            errCode = 5002;
            List<FieldError> fieldErrors = ((BindException) e).getFieldErrors();
            for (FieldError fieldErr : fieldErrors) {
                message.append(fieldErr.getDefaultMessage()).append(";");
            }
        } else if (e instanceof MethodArgumentNotValidException) {
            // 参数不合法报错
            errCode = 50003;
            MethodArgumentNotValidException methodArgumentNotValidException = (MethodArgumentNotValidException) e;
            List<FieldError> fieldErrors = methodArgumentNotValidException.getBindingResult().getFieldErrors();
            for (FieldError fieldErr : fieldErrors) {
                message.append(fieldErr.getDefaultMessage()).append(";");
            }
        } else if (e instanceof ProductServiceException) {
            // 业务报错
            ProductServiceException productServiceException = (ProductServiceException) e;
            message = new StringBuilder(productServiceException.getMessage());
            errCode = productServiceException.getErrCode();
        } else {
            // 其他报错
            errCode = 500;
            message = new StringBuilder(ErrorCodeEnum.UNKNOWN_ERR.getDesc() + ":" + e.getMessage());
        }
 log.error("系统全局异常定位:{}", Arrays.stream(e.getStackTrace()).limit(3).collect(Collectors.toList()));
 
        log.error(e.getMessage(), e);
        ResponseDTO<T> responseBean = new ResponseDTO<>();
        responseBean.setMessage(message.toString());
        responseBean.setCode(errCode);
        responseBean.setStatusCode(500);
        return responseBean;
    }
 
}

异常什么时候抛出，什么时候捕获呢？

程序上：捕获，是程序继续还会执行，抛出，当前程序会中断

个人业务需求上：某个字段的、或者众多批次中有个别失败，在不影响大局的情况下捕获。

基本原则：能抛则抛

扩展：

@ControllerAdvice + ResponseBodyAdvice接口实现参数返回的统一格式

@ControllerAdvice + RequestBodyAdvice 接口实现参数入参的统一格式

42、jackson 对象转换成字符串，日期问题

场景：公司使用jackson转换成字符串时，发现日期对象变成了时间戳的方式。一般使用jackSon会处理很多不同类型的对象，而有的对象的日期对象是：Date ，有的又是 LoaclDateTime 对象。。。

解决： Data使用 SimpleDateFormat格式化，LoaclDateTime使用JavaTimeModule格式化，且可以同时使用。

方法：


public String dddd(Object object){
 
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
        JavaTimeModule javaTimeModule = new JavaTimeModule();
        javaTimeModule.addDeserializer(LocalDateTime.class,
                new LocalDateTimeDeserializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        javaTimeModule.addSerializer(LocalDateTime.class,
                new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
        objectMapper.registerModule(javaTimeModule);
 
        String contentJson = null;
        try {
            contentJson = objectMapper.writeValueAsString(content);
        } catch (JsonProcessingException e) {
            log.error("get json from value failed! value[" + content + "].", e);
        }
 
        returen contentJson ;
 
}

43、ThreadLocal修饰符的作用：

多个线程各自拷贝一份 ThreadLocal修饰的变量到自己本地，即：不会对原本的变量修改，只修改副本。

注：ThreadLocal变量通常设置为static的原因：避免每次使用该类就创建该变量，节省空间。不然，每次创建一个值相等的对象，但这些对象的地址又不同，造成浪费

一个ThreadLocal实例对应当前线程中的一个TSO实例。因此，如果把ThreadLocal声明为某个类的实例变量（而不是静态变量），那么每创建一个该类的实例就会导致一个新的TSO实例被创建。显然，这些被创建的TSO实例是同一个类的实例。于是，同一个线程可能会访问到同一个TSO（指类）的不同实例，这即便不会导致错误，也会导致浪费（重复创建等同的对象）！因此，一般我们将ThreadLocal使用static修饰即可。
原文链接：https://blog.csdn.net/u013543848/article/details/102980066

(74条消息) 深入学习java源码之ThreadLocal.get()()与ThreadLocal.initialValue()_wespten的博客-CSDN博客_java threadlocal.get

44、sql为某字段设置默认值、修改字段类型、sql自动设置更新时间

注：其实这是覆盖操作，所以记得可能需要补上一些额外的限制语句，如下：unsingned not null


//添加默认值、并且修改备注
alter table tableXXXXX modify column product_status tinyint(3) unsigned NOT NULL default  1 comment '1 草稿，4下架，11上架';

让sql维护更新时间、创建时间


//修改tableXXXXX 表的created_at  字段设置为timestamp 类型，并设置默认值为 创建该记录的时间
ALTER TABLE tableXXXXX MODIFY created_at  timestamp DEFAULT CURRENT_TIMESTAMP;
 
//修改tableXXXXX 表的created_at  字段设置为timestamp 类型，并设置默认值为 更新该条记录的时间
ALTER TABLE tableXXXXX MODIFY updated_at  timestamp DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP;
 
 
好处： java代码中，就不用再写设置 这两个字段的业务逻辑了。

45、java调用python模型、服务

思路：http

python服务开启代码：


from flask import Flask,request
app = Flask(__name__)
 
 
@app.route("/", methods=["POST"])
def hello():
    print(request.form["name"])
    return "Hello World!"
 
@app.route("/recommend_gpt", methods=["GET"])
def recommend_gpt():
    user_id = request.args.get("user_id")
    # 在这里可以使用user_id参数来执行其他逻辑
    return "Hello, user with ID {}".format(user_id)
 
 
 
if __name__ == "__main__":
    app.run(port='8080')

java调用代码：


import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;
 
import java.net.URI;
import java.util.HashMap;
import java.util.Map;
 
public class TestRcp {
 
    public static void main(String[] args) {
        RestTemplate restTemplate = new RestTemplate();
        String  url="http://127.0.0.1:8080/";
        MultiValueMap<String,String> params = new LinkedMultiValueMap<>();
        params.add("name","张三");
        Object object1=  restTemplate.postForObject(url,params,String.class);
        System.out.println();
    }
 
}

46、springBoot配置主从数据的配置文件：

关键词：主从复制，多数据源

步骤1：maven依赖：


 <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
            <version>4.1.1</version>
            <exclusions>
                <exclusion>
                    <groupId>org.codehaus.groovy</groupId>
                    <artifactId>groovy</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

步骤2：application.properies文件


#配置主从数据源，要基于MySQL主从架构。
spring.shardingsphere.datasource.names=m0,s0
 
spring.shardingsphere.datasource.m0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.m0.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.m0.jdbc-url=jdbc:mysql://192.168.11.131:3306/product-service?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=utf-8
spring.shardingsphere.datasource.m0.username=root
spring.shardingsphere.datasource.m0.password=11
 
spring.shardingsphere.datasource.s0.type=com.zaxxer.hikari.HikariDataSource
spring.shardingsphere.datasource.s0.driver-class-name=com.mysql.cj.jdbc.Driver
spring.shardingsphere.datasource.s0.jdbc-url=jdbc:mysql://192.168.11.132:3306/product-service?zeroDateTimeBehavior=convertToNull&useUnicode=true&characterEncoding=utf-8
spring.shardingsphere.datasource.s0.username=root
spring.shardingsphere.datasource.s0.password=11
spring.shardingsphere.datasource.s0.connection-timeout=60000  //配置超时，想要看值设置 参考 项目启动时 注入数据源的 对象，看其属性的设置值情况
#读写分离规则， m0 主库，s0 从库
spring.shardingsphere.sharding.master-slave-rules.ds0.master-data-source-name=m0
spring.shardingsphere.sharding.master-slave-rules.ds0.slave-data-source-names=s0
 
spring.shardingsphere.props.sql.show=false
spring.shardingsphere.props.check.table.metadata.enabled=false
spring.shardingsphere.props.max.connections.size.per.query=100

此处m0库负责增删改，s0负责查询，两处数据源可以配置不同，也可以配置为同一个数据源

47、sprignboot 配置nacos

1、maven依赖


 <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
            <version>${nacos.config.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>guava</artifactId>
                    <groupId>com.google.guava</groupId>
                </exclusion>
            </exclusions>
        </dependency>

2、配置文件：

bootstrap.properties内容：


spring.cloud.nacos.config.group=DEFAULT_GROUP  //指定nacos上的组
spring.cloud.nacos.config.file-extension=properties
spring.cloud.nacos.config.server-addr=nacos-server.dev.interfocus.tech:443
spring.cloud.nacos.config.namespace=771917b3-7305-4be2-XXXX-efd6c9860a5f  //每个环境naocs上的唯一id
spring.cloud.nacos.config.refresh-enabled=true
spring.cloud.nacos.config.enabled=true

48、通过断点调试-查看数据源（借助mybatis的mapper）

49、任务调度xxj-box：

优势，可以通过界面去管理或触发任务执行，比@schedule 注解强多了，后者是死的、定时的，一般用于单机上的执行。

使用：

步骤1：maven依赖:


  <dependency>
            <groupId>com.xuxueli</groupId>
            <artifactId>xxl-job-core</artifactId>
            <version>${xxljob.version}</version>
        </dependency>

步骤2：bootstrap.properties


xxl.job.admin.addresses=https://xxl-job.dev.interfocus11.tech/
xxl.job.accessToken=
xxl.job.executor.appname=11-community-service
xxl.job.executor.address=
xxl.job.executor.ip=
xxl.job.executor.port=9081
xxl.job.executor.logpath=/var/log/java/xxl-community
xxl.job.executor.logretentiondays=30

步骤3：配置类bean注入


package com.11.community.config;
 
import com.xxl.job.core.executor.impl.XxlJobSpringExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
 
@Configuration
public class XxlJobConfig {
    private final   Logger logger = LoggerFactory.getLogger(XxlJobConfig.class);
 
    @Value("${xxl.job.admin.addresses}")
    private String adminAddresses;
 
    @Value("${xxl.job.accessToken:}")
    private String accessToken;
 
    @Value("${xxl.job.executor.appname}")
    private String appname;
 
    @Value("${xxl.job.executor.address:}")
    private String address;
 
    @Value("${xxl.job.executor.ip:}")
    private String ip;
 
    @Value("${xxl.job.executor.port}")
    private int port;
 
    @Value("${xxl.job.executor.logpath}")
    private String logPath;
 
    @Value("${xxl.job.executor.logretentiondays}")
    private int logRetentionDays;
 
    /**
     *  执行器
     *
     * @return XxlJobSpringExecutor
     */
    @Bean
    public XxlJobSpringExecutor xxlJobExecutor() {
        logger.info(">>>>>>>>>>> xxl-job config init.");
        XxlJobSpringExecutor xxlJobSpringExecutor = new XxlJobSpringExecutor();
        xxlJobSpringExecutor.setAdminAddresses(adminAddresses);
        xxlJobSpringExecutor.setAppname(appname);
        xxlJobSpringExecutor.setAddress(address);
        xxlJobSpringExecutor.setIp(ip);
        xxlJobSpringExecutor.setPort(port);
        xxlJobSpringExecutor.setAccessToken(accessToken);
        xxlJobSpringExecutor.setLogPath(logPath);
        xxlJobSpringExecutor.setLogRetentionDays(logRetentionDays);
        logger.info(">>>>>>>>>>> xxl-job adminAddresses=" + adminAddresses + " appname=" + appname + " port=" + port);
        return xxlJobSpringExecutor;
    }
 
 
 
}

步骤4：使用样例：


package com.11.community.controller.xxljob;
 
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.11.community.bo.PostFactorBo;
import com.11.community.bo.PostScoreTempBo;
import com.11.community.bo.es.PostProductIdBo;
import com.11.community.bo.es.PostProductIdTempBo;
import com.11.community.bo.es.ProductIndexEs;
import com.11.community.constant.BaseConstant;
import com.11.community.entity.PostScore;
import com.11.community.query.post.PostsWithProductQuery;
import com.11.community.service.IPostScoreService;
import com.11.community.service.IPostService;
import com.11.community.utils.DateUtils;
import com.11.community.utils.DecimalUtils;
import com.xxl.job.core.handler.annotation.XxlJob;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.lucene.search.join.ScoreMode;
import org.elasticsearch.index.query.QueryBuilders;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.SearchHit;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
 
import java.text.ParseException;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
 
/**
 * 
 * xxl job定时任务
 *
 * @Author mcj
 * @Date 2022/2/15
 */
@Slf4j
@Component
public class PostSortJobHandler {
 
    @Autowired
    private IOpenSearchCommonService commonService;
 
    /**
     * xxl job 调用
     */
   @ApiOperation("同步数据到openSearch信息")
    @XxlJob(value = "openSearchPut") //我们的 任务调度的执行器 就叫 openSearchPut
    public void queryAndPut() {
        String productIds = XxlJobHelper.getJobParam();//获取 xxl-job的参数，如果不传，则是空字符串
        try {
            commonService.startTask(productIds);
        }catch (Exception e){
            log.error(e.getMessage());
            e.printStackTrace();
            throw e;
        }finally {
            MybatisPlusConfig.myTableName.set("");
        }
    }

步骤5：登录xxl-job的控制台去查看：

idea控制台也可以看见是否注册成功

xxl-job的控任务调度执行也可以核对是否注册上来：

步骤5：在任务调度中心配置我们的这个执行器上面时候执行，执行时携带什么参数：

50、springBoot加载配置文件相关问题

关键词：@value赋值失败、指定加载配置文件失败、no active profile set

场景：使用配置类时，注入bean，该bean依赖@valu("${XXX}"),发现报错没解析，如下：

（注：截图中 port的值的value实际写错了，导致项目一直卡住，不报错也没信息输出）

发现：编译后的target目录没有配置文件，那么需要在pom中设置如下：


  <build>        
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

待续.....

51、springboot 日志只输出 springboot和mybatis的的logo

场景：项目启动。没有详细的信息，只有框架logo输入，如下：

原因：和日志输出有关。应该是日志路径或者日志配置有问题。自己创建了新环境的配置文件而日志配置文件中没有配该环境下的：

解决：

扩展：

日志模板：

application.properties的日志文件配置：


#指定日志文件的配置文件
logging.config=classpath:logback-spring.xml
#日志的输出等级，可以指定具体某个目录下的才输出，如果 设置 logging.level.root=debug 则整个项目含jar包中的也输出的 贼多
logging.level.com.example=debug
logging.file.path=/log

logback-spring.xml的日志模板配置：


<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!--日志输出格式设置-->
    <property name="CONSOLE_LOG_PATTERN"
              value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>
    <!--日志颜色的设置-->
    <conversionRule conversionWord="clr"
                    converterClass="org.springframework.boot.logging.logback.ColorConverter"/>
    <conversionRule conversionWord="wex"
                    converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter"/>
    <conversionRule conversionWord="wEx"
                    converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter"/>
    <!--自己也可以定义转换规则，如 第三方日志收集器kinesis 接受的是json的字符串流，那我们需要把 日志输出 以json的格式输出-->
<!--    <conversionRule conversionWord="message" converterClass="com.XXX.common.converter.MyMessageConverter"/>-->
 
    <!--从application.properties 加载一些变量 如路径、项目名称（用于自定义log文件名称）
     如：取变量：logging.file.path的值 在本文件声明为 log_path，使用时格式：${log_path}
     如：取变量：log.project.name的值 在本文件声明为 project_name 使用时格式：${project_name}     -->
    <springProperty scope="context" name="log_path" source="logging.file.path"/>
    <springProperty scope="context" name="project_name" source="log.project.name"/>
 
 
    <!--控制台输出-->
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${CONSOLE_LOG_PATTERN}</pattern>
        </encoder>
    </appender>
 
    <!--日志文件输出到文件设置-->
    <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <!-- 每天日志归档路径以及格式 -->
            <fileNamePattern>${log_path}/${project_name}.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxFileSize>100MB</maxFileSize>
            <maxHistory>30</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
    </appender>
 
    <!--不同环境下 设置输出的流：是输出到控制台stdout、还是输出到文件file,还是都输出？-->
    <springProfile name="test">
        <root level="info">
            <!--将流输出到控制台-->
            <appender-ref ref="stdout"/><!--已经在appender定义了-->
            <!--将流输出到文件-->
            <appender-ref ref="file"/><!--已经在appender定义了-->
            <!--将流输出到第三方日志收集平台 如 kinesis-->
            <!--            <appender-ref ref="KINESIS"/>--> <!--那么也需要在appender定义-->
        </root>
    </springProfile>
    <springProfile name="alpha">
        <root level="info">
            <appender-ref ref="stdout"/>
            <appender-ref ref="file"/>
        </root>
    </springProfile>
    <springProfile name="prod">
        <root level="info">
            <appender-ref ref="stdout"/>
            <appender-ref ref="file"/>
        </root>
    </springProfile>
    <springProfile name="dev">
        <root level="info">
            <appender-ref ref="stdout"/>
            <appender-ref ref="file"/>
        </root>
    </springProfile>
    <!--不指定环境的情况下（使用 默认环境）-->
    <springProfile name="default">
        <root level="info">
            <appender-ref ref="stdout"/>
            <appender-ref ref="file"/>
        </root>
    </springProfile>
</configuration>

52、观察接口报警的工具-可视化工具

（可能配置麻烦）

grafana 是一款采用 go 语言编写的开源应用，是一个跨平台的开源的度量分析和可视化工具，可以通过将采集的数据查询然后可视化的展示，并及时通知

配置样例：

钉钉自定义机器人接入：自动发到群消息：

https://blog.csdn.net/u013372493/article/details/124819854

53、工具-将大文件划分成小文件


//inputFile 文件路径
//outputFile 输出路径
// gb  拆分文件的大小， 单位gb
public static void fileToSamll(String inputFile, String outputFile,int gb) {
 
        try {
            int hash = gb * 1024 * 1024 * 1024;
 
            FileReader read = new FileReader(inputFile);
            BufferedReader br = new BufferedReader(read,10*1024 * 1024);
            String row;
 
            int num = 0;
 
            int fileNo = 1;
            FileWriter fw = new FileWriter(outputFile+fileNo +".csv");
            while ((row = br.readLine()) != null) {
                num =row.length() +num;
                fw.append(row + "\r\n");
                if((num / hash) > (fileNo - 1)){
                    fw.close();
                    fileNo ++ ;
                    fw = new FileWriter(outputFile+fileNo +".csv");
                }
            }
            fw.close();
            System.out.println("fileNo="+fileNo);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

54、springBoot记录日志

1、配置文件 logback-spring.xml


<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!--日志输出格式设置-->
    <property name="CONSOLE_LOG_PATTERN"
              value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>
    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter"/>
    <conversionRule conversionWord="wex"
                    converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter"/>
    <conversionRule conversionWord="wEx"
                    converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter"/>
 
<!--    <conversionRule conversionWord="message" converterClass="com.aaa.common.converter.aaaMessageConverter"/>-->
<!--    <conversionRule conversionWord="exception" converterClass="com.aaa.common.converter.aaaExMessageConverter"/>-->
<!--    <conversionRule conversionWord="server_addr" converterClass="com.aaa.product.config.IpConverterConfig"/>-->
<!--    <springProperty scope="context" name="kinesis.region"  source="kinesis.region" />-->
<!--    <springProperty scope="context" name="kinesis.streamName" source="kinesis.streamName"/>-->
    <!--log.path 变量在application.properties 有配置-->
    <springProperty scope="context" name="log_path" source="log.path"/>
    <!--project_name变量在application.properties 有配置-->
    <springProperty scope="context" name="project_name" source="log.project.name"/>
 
 
<!--    <appender name="KINESIS" class="com.gu.logback.appender.kinesis.KinesisAppender">-->
<!--        <bufferSize>1000</bufferSize>-->
<!--        <threadCount>20</threadCount>-->
<!--        <region>${kinesis.region}</region>-->
<!--        <maxRetries>3</maxRetries>-->
<!--        <shutdownTimeout>30</shutdownTimeout>-->
<!--        <streamName>${kinesis.streamName}</streamName>-->
<!--        <encoding>UTF-8</encoding>-->
<!--        <layout class="ch.qos.logback.classic.PatternLayout">-->
<!--            <pattern>{"created_time":"%d{yyyy-MM-dd HH:mm:ss.SSS,UTC}","project_name":"${project_name}","server_ip":"%server_addr","current_thread":"%thread","client_ip":"%mdc{CLIENT_IP}","class":"%class{255}","line":"%line","level_name":"%level","message":"%message","stack_trace":"%exception{100}"}-->
<!--            </pattern>-->
<!--        </layout>-->
<!--    </appender>-->
 
    <!--控制台输出-->
    <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${CONSOLE_LOG_PATTERN}</pattern>
        </encoder>
    </appender>
 
    <!--日志文件输出-->
    <appender name="file" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
            <fileNamePattern>${log_path}/${project_name}.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <maxFileSize>100MB</maxFileSize>
            <maxHistory>30</maxHistory>
        </rollingPolicy>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
        </encoder>
    </appender>
 
<!--    <logger name="KinesisLogger" additivity="false">-->
<!--        <appender-ref ref="KINESIS"/>-->
<!--    </logger>-->
 
 
    <springProfile name="test">
        <root level="info">
            <appender-ref ref="stdout"/>
            <appender-ref ref="file"/>
<!--            <appender-ref ref="KINESIS"/>-->
        </root>
    </springProfile>
    <springProfile name="alpha">
        <root level="info">
            <appender-ref ref="stdout"/>
            <appender-ref ref="file"/>
<!--            <appender-ref ref="KINESIS"/>-->
        </root>
    </springProfile>
    <springProfile name="prod">
        <root level="info">
            <appender-ref ref="stdout"/>
            <appender-ref ref="file"/>
<!--            <appender-ref ref="KINESIS"/>-->
        </root>
    </springProfile>
    <springProfile name="dev">
        <root level="info">
            <appender-ref ref="stdout"/>
            <appender-ref ref="file"/>
            <!--            <appender-ref ref="KINESIS" />-->
        </root>
    </springProfile>
    <springProfile name="default">
        <root level="info">
            <appender-ref ref="stdout"/>
            <appender-ref ref="file"/>
            <!--            <appender-ref ref="KINESIS" />-->
        </root>
    </springProfile>
</configuration>

注：如果控制台有日志打印，但是日志文件没有日志打印，请查看springboot的启动环境，不指定环境，则是 default，如下：

那么去检查，springProfile name="default" 是否存在。（上文的配置有给出，所以存在）

55、springboot 配置ncoas,指定配置不生效

场景：开发项目，引入nacos。死活连接不上远程的nocas配置。配置如下：

maven依赖：


  //springboot版本是2.3.12.RELEASE
 
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
            <version>2.2.7.RELEASE</version>
        </dependency>

配置文件：application.properties


spring.application.name=11-searchTemp
spring.profiles.active=dev
 
spring.cloud.nacos.config.group=DEFAULT_GROUP
spring.cloud.nacos.config.file-extension=properties
spring.cloud.nacos.config.namespace=771917b3-7305-4be2-9c0b-efd6c9860a5f
spring.cloud.nacos.config.server-addr=XXXXXXX:443
spring.cloud.nacos.config.refresh-enabled=true
spring.cloud.nacos.config.enabled=true

问题：配置了这些配置和没配一样，问题排查方法：

发现NacosPropertySourceBuilder 类输出的这个 Igrore the empty nacos XXX,所以全局查找（idea 中，按两次sheift） r如下：

找到日志的代码：

考虑到，是其他调用此方法输出的这些，那么断点调试，找到调用此方法的函数，看看传入的数据对不对就行了！

这样跳出函数几次，很有可能就找到我们配置的数据，开始没加载我们指定的数据，这里都是默认的localhost:8848 等其他默认。

原因找到了，是没加载配置文件，为什么没加载我们指定的配置呢？

扩展知识：bootstrap优先级高于 appliaction文件，yml优先级高于properties。

经验建议：提早配置、引导配置尽量配置到 bootstrap中

application.properties和 bootstrap.yml 区别 - 简书

问题解决：将项目中的 application.properties 文件名修改为 bootstrap.properties

读取远程的配置文件验证：

个人心得：application 更注重的是应用本身的上下文引导，bootstrap是程序启动时的引导，包含了应用上下文的引导

56、谷歌API、aws亚马逊API

1、谷歌翻译

前提是公司已经给你申请了秘钥key

详情参考：

官方参考：快速入门 | Cloud Translation | Google Cloud 谷歌翻译SDK （Google Translate SDK）的使用_nicolelili1的博客-CSDN博客_谷歌翻译开放平台

步骤开始：未安装或者配置上述博客的的任何东西。

步骤1：引入依赖


        <dependency>
            <groupId>com.google.cloud</groupId>
            <artifactId>google-cloud-translate</artifactId>
            <version>2.1.13</version>
        </dependency>

步骤2:接口调用


package com.search.service.impl;
 
import com.google.cloud.translate.Translate;
import com.google.cloud.translate.TranslateOptions;
import com.google.cloud.translate.Translation;
import com.google.cloud.translate.v3.*;
import com.11.search.service.IGoogleTranslationService;
import org.springframework.stereotype.Service;
 
import java.io.IOException;
 
/**
 * @author wwwV_Jb0
 * * @date 2022/5/13
 */
@Service
public class GoogleTranslationServiceImpl implements IGoogleTranslationService {
    @Override
    public String translateToEn(String keyword) throws IOException {
        
        //该秘钥是 付费的，一般是AIz开头的
        String key="xxxxxxxxxxxxxxxxxxx";
        Translate translate = TranslateOptions.newBuilder().setApiKey(key).build().getService();
        String targetLanguage = "en";
        String sourceLanguage  = "zh-CN";//可以传空 会自动检测原语种
        Translate.TranslateOption srcLang = Translate.TranslateOption.sourceLanguage(sourceLanguage);
        Translate.TranslateOption tgtLang = Translate.TranslateOption.targetLanguage(targetLanguage);
        // Use translate `model` parameter with `base` and `nmt` options.
        Translate.TranslateOption model = Translate.TranslateOption.model("base");
 
        String sourceText = "裙子 ";
        Translation translate1 = translate.translate(sourceText, srcLang, tgtLang, model);
        String translatedText = translate1.getTranslatedText();
        System.out.println(translatedText);
 
        return null;
    }
}

打印：,如果秘钥错误，则会报错：如下：


。。。。。
com.google.api.client.googleapis.json.GoogleJsonResponseException: 400 Bad Request
GET https://translation.googleapis.com/language/translate/v2?key=AIzaSyBmdOdgjKSPKDfiUTW1EAwe5bVLPzfXXXX&model=base&q=%E8%A3%99%E5%AD%90%20&source=zh-CN&target=en
{
  "code" : 400,
  "details" : [ {
    "@type" : "type.googleapis.com/google.rpc.ErrorInfo",
。。。。。

可以看出，调用api也是发送请求，只不过参数进行了拼接，所以直接通过 restTemplate发送get请求应该也是可以。如下，验证也是成功的的。

主要是如何拼接url的get请求：

格式如下：


//共4个参数： key、model、q(即关键字) 、source（原始语言）、target（目标语言）
https://translation.googleapis.com/language/translate/v2?key=AIzaSyBmdOdgjKSPKDfiUTW1EAhe5bVXXXXX&model=base&q=长裙&source=zh-CN&target=en

2、谷歌认证实现

方式一：比较原始的request请求

（谷歌文档的风格）

）

首先，为了避免多次创建客户端，多次读取密钥，所以将创建的客户端通过java的配置类注入spring中

认证代码：（基本原理使用谷歌的对象，对request对象设置一些认证的操作

使用上：


//方法一认证： 其中， google-credentials是谷歌授权账号去“凭证”下载的json密钥
    @Bean
    public GoogleCredential googleAuthorize() throws IOException {
        ClassPathResource resource = new ClassPathResource("google-credentials.json");
        return GoogleCredential.fromStream(resource.getInputStream()).createScoped(Collections.singleton("https://www.googleapis.com/auth/cloud-platform")).setExpirationTimeMilliseconds(new Long(3600000L));
    }
 
    @Bean    
    public HttpRequestFactory httpRequestFactory() throws GeneralSecurityException, IOException {
        HttpTransport httpTransport = GoogleNetHttpTransport.newTrustedTransport();
        return httpTransport.createRequestFactory();
    }
 
-------------------------------------------------------使用方面------------------------
public void sss(){
//其中map是我们的请求体，即依据json字符串，构造的map。如：{“name”:"李四"} 则map.put("name","李四")  
 
//调用谷歌的buildPostRequest获取request
HttpRequest request = httpRequestFactory.buildPostRequest(new GenericUrl(谷歌文档某API的URL), new JsonHttpContent(new GsonFactory(), map));
//给谷歌的HttpRequest 设置密钥
googleAuthorize.initialize(request);
HttpResponse response = request.execute();
System.out.println(response.parseAsString());
}
 
注：如果报错40X，请依据返回的报错结果，调整json，一般是构造的map和json对不上，另一个是 value的类型不对（常规字段基本均为字符串）

方式二：谷歌对象的认证


方法二：谷歌的风格都是 XXXServiceClient客户端，想要对其设置 传入xxxServiceSettings 对象即可
    @Bean
    public Credentials getCredentials() throws IOException {
        ClassPathResource resource = new ClassPathResource("google-credentials.json");
        return ServiceAccountCredentials.fromStream(resource.getInputStream());
    }
 
    @Bean
    public XXXServiceClient XXXServiceClient() throws IOException {
        Credentials creds = this.getCredentials();
        XXXServiceSettings xxxServiceSettings = XXXServiceSettings.newBuilder().setCredentialsProvider(FixedCredentialsProvider.create(creds))).build();
        return XXXServiceClient.create(xxxServiceSettings);
    }
 
---------------------------------使用方面----------------------------------------------
基本和XXXServiceClient的方法有关，不太灵活只能调用该客户端提供的一些方法，但是方便和标准
 
 
注：谷歌提供的对象、或者要传入函数的对象 一般都不可new， 
而是  XXXX对象.newBuilder().setXXX()......bulid();

方式三：有时候可能业务安全方面，本地不让保存 google-credentials.json，需要配置在配置中心去管理，所以我们可以先把 google-credentials.json内容变成字符串（可通过map一个一个属性put再转成字符串）。


 
    @Value("${google.search.key}")
    private String googleSearchKey;
    @Bean
    public Credentials getCredentials() throws IOException {
        //map变成输入流
//        InputStream in = new ByteArrayInputStream(JSON.toJSONString(map).getBytes());
//        ClassPathResource resource = new ClassPathResource("google-credentials.json");
        return ServiceAccountCredentials.fromStream(new ByteArrayInputStream(googleSearchKey.getBytes()));
    }

aws亚马逊api调用技巧：

身份认证：


@Configuration
public class AWSConfig {
 
    @Value("${aws.accessKeyId}")
    private String awsAccessKeyId;
    @Value("${aws.seretACCessKey}")
    private String awsAccessKeySecet;
 
    @Bean
    public PersonalizeClient personalizeClient() {
        AwsBasicCredentials awsCreds = AwsBasicCredentials.create(awsAccessKeyId, awsAccessKeySecet);
        return PersonalizeClient.builder().credentialsProvider(StaticCredentialsProvider.create(awsCreds)).region(Region.US_WEST_2).build();
    }
}

java文档参考：aws-doc-sdk-examples/javav2 at main · awsdocs/aws-doc-sdk-examples (github.com)

该github项目的所有示例代码，除了没有按照其配置认证环境，而是需要提供代码实现认证，

惯用模板套路：通过获取 XXXCredentials.create（） 获取证书对象，然后把这个对象丢到某目标客户端：

XXXClient.builder().credentialsProvider(XXXXCredentialsProvider.create(awsCreds)).region(Region.US_WEST_2).build();

其实很多时候，第三方认证让配置系统环境变量，即在项目启动前先用代码或者指定jvm参数进行设置，如:

文章参考：【SpringBoot】启动前执行的几种方式_可耳（keer）的博客-CSDN博客

59、get请求，下划线请求参数封装进对象

场景：get请求模式不准变化的需求，且众多参数，接收参数的对象，如果属性和get请求携带的参数一模一样，自然会接收成功，如下：


get 请求： XXX/XX/site_id=100&param1=&....
 
接收该请求要封装的对象：
 
@Data
public QO{
 
private Integer site_id;
private String param1;
}

这样，调用时，可能是 qo.getSite_id(); 非常丑。

所以，通过以下实现：

和上述方法一样，但是生成set、get方法后，将方法名修改去掉下划线，并删除 set方法，如下：


@Data
public QO{
 
  private Integer site_id;
  private String param1;
 
//切记 不能要 get_siet_id的方法
public get siteId(){  return site_id;}
public get param1(){  return param1;}
 
}

57、查询日志es的kibaba

查询思路：先理解你公司所在的索引字段，一般是某个模块会应了一个项目名称字段：如project_name，想要查看日志是否发送错误，可以看 level字段：于是写出的查询语句为：

product_name:"模型名称" AND level "error"

其中，level是你公司在同步到es上 log.error的信息一般通过脚本同步解析，赋值该字段，

一般的 log.info 日志信息会放到 message字段（我公司是这样设计的表结构，每个公司不一样哈）

例如：下面想查询: product-service 模块的日志且 log.info输出 query:default;

或：使用

技巧：当一个项目很大时，线程很多，依据日志排错，日志相关时间段内打印的日志是各个线程掺杂着出现的，这时候我们可以评估单位时间内（如5分钟、1分钟，主要看时间段内的日志数量来确定）按线程聚合，甚至抛出异常的都不知道是哪个接口抛出的（如IOException：Broken pipe）

使用dev tool的方式查询示例：


 
 
GET java-log-2022-06-21/_search
{
    "query": {
        "bool": {
            "must": [
                {
                    "match_phrase": {
                        "project_name": {
                            "query": "product-service"
                        }
                    }
                },
                {
                    "match_phrase": {
                        "message": {
                            "query": "query:default:"
                        }
                    }
                }
            ]
        }
    },
    "_source": [
   "project_name",
    "message"
  ],
      "from": 0,
    "size": 10000
}

扩展：IOException：broken pipe

原因：A请求B，B还在处理A的请求，A这时候就不等待结果取消了请求

①在linucx系统上报错为： IOException：broken pipe

②在window系统上报错为：java.io.IOException: 远程主机强迫关闭了一个现有的连接。

58、命令行查看本地Maven仓库地址 linux环境下：

1. 如果是只需要查看本地仓库的话可以使用如下命令：（会下载，然后打印路径）

mvn help:evaluate -Dexpression=settings.localRepository | grep -v '
$I N F O$ $INFO$ '

默认路径:/home/用户/.m2/repository

2. 在运行maven命令时，添加-X 或者 -Debug参数

mvn -X

会打印出相关结果

...
[DEBUG] Reading global settings from C:\Maven\conf\settings.xml
[DEBUG] Reading user settings from C:\segphault\.m2\settings.xml
[DEBUG] Using local repository at C:\Repo

文章参考：命令行查看本地Maven仓库地址_xinglu31的博客-CSDN博客_linux maven 默认仓库地址

59、springboot加载resource文件夹下的自定义文件

方式1：

 String path = this.getClass().getClassLoader().getResource("my.json").getPath();

方式2：(推荐)

 ClassPathResource resource = new ClassPathResource("my.json");

60、jar 包在后台运行

nohup java -jar babyshark-0.0.1-SNAPSHOT.jar > log.file 2>&1 &

上面的2 和 1 的意思如下:

0 标准输入（一般是键盘）
1 标准输出（一般是显示屏，是用户终端控制台）
2 标准错误（错误信息输出）

参考：(89条消息) Java -jar 如何在后台运行项目_刘信坚的博客的博客-CSDN博客_jar如何在后台运行

61、架构师的素养

架构设计的主要目的是为了解决软件系统复杂度带来的问题，解决：高性能、高可用、可扩展

网友感悟是:架构即(重要)决策，是在一个有约束的盒子里去求解或接近最合适的解。这个有约束的盒子是团队经验、成本、资源、进度、业务所处阶段等所编织、掺杂在一起的综合体(人，财，物，时间，事情等)。

架构无优劣，但是存在恰当的架构用在合适的软件系统中，而这些就是决策的结果。需求驱动架构。

在分析设计阶段，需要考虑一定的人力与时间去"跳出代码，总揽全局"，为业务和IT技术之间搭建一座"桥梁"。

至少应该拿出3种架构方案，避免个人局限性。

对方案的选择可以通过：

数量对比法：简单地看哪个方案的优点多就选哪个
优缺点的加权法对比：让业务人员对质量属性进行排序

（质量属性：如：性能、复杂度、人力、硬件成本、可靠性、可维护性）

今日得到:

1 架构是为了应对软件系统复杂度而提出的一个解决方案。

2 架构即(重要)决策

3 需求驱动架构，架起分析与设计实现的桥梁

4 架构与开发成本的关系

依据原则：合适原则、简单原则、演化原则

62、redis技巧、缩短key长度

场景：搜索服务，调用第三方服务，为了降低成本，故做缓存，降低调用第三方服务的频率，用户体验也不错。但面对用户搜索请求，可能拼接很多条件，所以key应该如何设计呢？

思路：利用：相同的字符串经过md5算法，得到的 32位是一样的。因此，将参数对象变成字符串，通过（md5算法）映射成一个32位的字符串

解决：

总结：有时候，可以把当前问题转换等价成另一种方式。要有维度映射的思维

63、对象集合list 存成csv文件

关键词：list转csv

场景：虽然可以借助 csv依赖，一个字段一个字段的塞进去，但是效率慢

思路：根据csv是用逗号，作为单元格进行区分，那么我们利用反射，可以一劳永逸

解决方法：


package com.XX.product.utils;
 
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
 
public class ListToCsvUtil<T> {
 
    /**
     * @param list 对象列表
     * @param clazz 对象.class
     * @param header  是否需要表头
     * @return 对象属性值字符串
     */
    public String list2Csv(List<T> list, Class<T> clazz,Boolean header) {
 
        //创建
        List<Field> allFields = new ArrayList<>(100);
 
        // 获取当前对象的所有属性字段
        // clazz.getFields()：获取public修饰的字段
        // clazz.getDeclaredFields()： 获取所有的字段包括private修饰的字段
        allFields.addAll(Arrays.asList(clazz.getDeclaredFields()));
        // 获取所有父类的字段， 父类中的字段需要逐级获取
        Class clazzSuper = clazz.getSuperclass();
 
        // 如果父类不是object，表明其继承的有其他类。 逐级获取所有父类的字段
        while (clazzSuper != Object.class) {
            allFields.addAll(Arrays.asList(clazzSuper.getDeclaredFields()));
            clazzSuper = clazzSuper.getSuperclass();
        }
 
 
        StringBuilder stringBuilder = new StringBuilder();
        if(header) {
            List<String> fields = allFields.stream().map(Field::getName).map(String::valueOf).collect(Collectors.toList());
            String headerString = String.join(",", fields);
            stringBuilder.append(headerString).append("\n");
        }
 
         // 设置字段可访问， 否则无法访问private修饰的变量值
        for (Field field : allFields) {
            field.setAccessible(true);
        }
 
        for (T item : list) {
           List<String> objectList = new ArrayList<>();
            for (Field field : allFields) {
 
                try {
                    // 获取字段名称
                   // String fieldName = field.getName();
                    // 获取指定对象的当前字段的值
                    String fieldVal = field.get(item)+"";
                    objectList.add(fieldVal);
                  //  System.out.println(fieldName + "=" + fieldVal);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                }
 
            }
            String oneObject = String.join(",", objectList).replaceAll("\r\n"," ");
            stringBuilder.append(oneObject).append("\n");
        }
 
         for (Field field : allFields) {
            field.setAccessible(false);
        }
        return stringBuilder.toString();
    }
}

测试：

64、查询单表因数据量较大，导致sql耗时太久而失败。

关键词：mybatis分页、慢sql、耗时久

场景：没有表关联、纯粹因为查询表数据较大，导致查询失败，一般是数据导出类的场景遇见

思路：分批查询。最后再用 list.addAll(部分list) 得到最终结果。如果结果过大，则考虑批次设置稍大一点，文件分块传输。

分页代码：


        ArrayList<AwsTrueFitBO> resultList = new ArrayList<>();
  
        Long productCount = saleProductsService.selectCount(List.of(ProductConst.ONLINE, 
        for (int pageIndex = 0; pageIndex < (productCount / pageSize) + 1; pageIndex++) {
            List<AwsTrueFitBO> awsTrueFitBySize = getProductsByStatus(tableSuffix, pageIndex + 1, pageSize);
            if(!CollectionUtils.isEmpty(awsTrueFitBySize)) {
                resultList.addAll(awsTrueFitBySize);
            }
        }
        return resultList;


    public List<SaleProducts> getProductsByStatus(List<Integer> status, Integer start, Integer pageSize) {
 
 
//如果使用XXXMapper调用 则为 XXMapper.selectPage(xx,xx);//可看源码 很清晰
        IPage<SaleProducts> page = new Page<>(start, pageSize);
        page.setRecords(new ArrayList<SaleProducts>());
        return page(page, new LambdaQueryWrapper<SaleProducts>()
                .in(SaleProducts::getProductStatus,status)
                .isNull(SaleProducts::getDeletedAt)
                .orderByAsc(SaleProducts::getId))
                .getRecords();
    }

65、如何生成优雅的list
bug：

上面其实就是一个元素，实际应该为 List.of("1","2","5","7","8","15")

实际执行的sql日志如下：（原本期望，应该有）

使用技巧：

List.of(数组)

Arrays.asList(数组)

66、JSON与对象转换的坑（1）

场景：放入缓存的对象，再取出时，发现缺少下划线

原因分析：发现缺少下划线的字段，都是用了 @JsonProperty注解进行标注，而放入缓存时，使用的是JSON.toJSONString（）方法转换成字符串进行存储的。经过实验测试，发现 JSON.toJSONString（）方法打印的原始的属性名称。

解决办法：使用：@JSONField代替@JsonProperty

对象上使用注解

JSON.toJSONString（实例对象）//方法，会打印 原始对象 ，如：打印的是json中的key是将是 minPrice

扩展：@JSONField代替@JsonProperty的区别

①所属包不一样，@JSONField是fastjosn包里的，@JsonProperty是json包里的

②转换对象，调用配合的方法不一样。

@JsonProperty 搭配ObjectMapper().writeValueAsString(实体类)方法使用，将实体类转换成字符串。搭配ObjectMapper().readValue(字符串)方法使用，将字符串转换成实体类

@JSONField 搭配JSON.toJSONString(实体类)方法使用，将实体类转换成json字符串。搭配JSON.parseObject(字符串,实体类.class)方法使用，将字符串转换成实体类。

③ @JSONField 是转换成JSON字符串时，使用JSON.toJSONString(）别名生效。

@ JsonProperty是转换成 JSON字符串时，使用JSON.toJSONString(）别名不效。

如果既想转对象也别名生效、又想转字符串也生效，那么就两个一块加！如：

扩展：

1、将json字符串转换成对象时，使用@JsonProperty是无效的，需要使用@JSONField

2、JSON字符串中含有不同key但都是同级，需求又是想把它们作为同级看做是一个list时，定义成Map即可。

如：A,B.C同级其中B是列表：


{
    "A": "1",
    "B": [
        "21",
        "22",
        "23"
    ],
    "C": 3
}

这定义的JAVA对象是：


class Obejct{
    private String A;
    private List<String> B;
    private String C;
}

JSON是如下情况时，应该使用map转换


{
    "A":"1",
    "B":{
        "B1":"21",
        "B2":"22",
        "B3":"23"
    },
    "C":3
}


class Obejct{
    private String A;
    private Map<String,Object> B;
    private String C;
}

测试结果

总结：对象本质就是Map，只不过的每个属性可以定义成不同的类型

JSON与对象转换的坑（2）

场景：使用fastjson解析json时，有些环境下，用boolean类型解析不到 is开头的属性

解决办法：尽量不使用is开头的属性，或者使用字符串去接收该json的值

67、列表分批处理小技巧

场景：有时候，我们业务需要处理较大的列表，可能会拿着这个列表去执行sql，导致查询慢、查询sql的结果大，甚至内存溢出。这时候就需要我们把大任务，分小点去处理。

分析：按正常操作，使用写个循环，算区间值，取区间XXList.subList(start,end) ，能做但是麻烦

更好的解决办法：使用java自带的 Lists.partion(列表，分批大小),遍历块，处理块！


         //创建20个元素的list
        List<Integer> list = new ArrayList<>(22);
        for (int i = 0; i < 22; i++) {
            list.add(i);
        }
        
        //按5个一组进行处理（输出）
        List<List<Integer>> partition = Lists.partition(list, 5);
        for (List<Integer> integers : partition) {
            System.out.println(integers);
        }

输出：

[0, 1, 2, 3, 4]
[5, 6, 7, 8, 9]
[10, 11, 12, 13, 14]
[15, 16, 17, 18, 19]
[20, 21]

68、限流器 RateLimiter

场景：上传数据过程中，调用第三方接口，每分钟不能超过100次请求，超过后将被直接抛出异常，多线程情况下，没法确保单位时间内的请求是否过于密集

分析：能不能参考缓存的涉及，生产这随便生产，但我消费者按固定速度去取？

解决办法：使用限流器

google开源工具包guava提供了限流工具类RateLimiter，该类基于“令牌桶算法”，非常方便使用。

代码使用：


import com.alibaba.nacos.shaded.com.google.common.util.concurrent.RateLimiter;
import org.springframework.util.StopWatch;
。。。。
  
public static void main(String[] args) {
       
        //1分钟内调test的次数不超过10次
        //限流器
        RateLimiter rateLimiter = RateLimiter.create(10);//其实参数就是QPS的值
        for (int i = 0; i < 1000; i++) {
            //计时器
            StopWatch stopwatch = new StopWatch();
            stopwatch.start();
 
            //执行目标函数
            rateLimiter.acquire();
            test();
 
            //打印执行多久
            stopwatch.stop();
            System.out.println( stopwatch.getTotalTimeMillis());
        }
 
    }
 
    public static void test(){
        System.out.println("test");
    }

执行结果：基本是100ms执行一次，实现了1秒执行10下的机制

多线程下使用：无论创建1个线程还是20个线程，下列输出只会输出每秒打印一次：

执行了 16669386XX035


import com.alibaba.nacos.shaded.com.google.common.util.concurrent.RateLimiter;
 
public class JsonTest {
 
 
 
    public static void main(String[] args) {
 
        //1分钟内调test的次数不超过100次
        //限流器
        RateLimiter rateLimiter = RateLimiter.create(1);
        for (int i = 0; i < 20; i++) { //101执行
            new Thread(new Runnable() {
                @Override
                public void run() {
                    while (true) {
                        if (rateLimiter.tryAcquire()) {
                            //执行
                            tagrget();
                        }
                    }
                }
            }).start();
        }
    }
 
    public static void tagrget() {
        System.out.println("执行了"+"  "+System.currentTimeMillis());
    }
}

另外，多线程使用同一个加锁的函数，让函数进行睡眠，也能起到限制调用

实现限流器的算法一般：

69、在idea排查CPU、内存OOM的方法

场景：在本地运行调试重新，寻找哪些方法比较占cpu、内存

工具：使用 profiler

步骤：

1、选取要观察的应用

2、右键可以看该应用的cpu、head memory 、threads如下：

3、最nb的功能是:(将会监听一段时间，然后你手动停止监听，就可以查看结果了。类似于医生听诊后，得出结论，该结论能查看每个函数占用的内存和cpu)

听诊结果：

蓝色部分，类似于堆栈信息，下一层级的是上一层级的总和，如

70 、记录一次OOM事故

场景：。应用部署一段时间后就停止了停止，日志有出现OOM。新增了3个任务，A任务每10分钟执行一次（2分钟左右能执行完成），B任务有一天执行一次（1小时左右能够执行完成）。AB每次执行均使用同一个线程池，且每个任务需要35个线程执行，C任务每次也需要有35个线程。执行4个小时左右。线程池设置如下：

原因分析：考虑到服务的的限制，A任务执行的又快，所以设置如上。事实上，单独运行A任务时的执行情况是：35个任务到提交到线程池，其中1-8个任务直接拿去现有的线程池开始执行，剩下的35-8=27个任务在linkedBockingQueue阻塞队里里等待，由于没有指定阻塞队里大小（默认：Ineger.max）因此，虽然没有达到 maximumPoolSize，但也不会再创建新线程，直至1-8个任务逐个完成，空闲的线程才去处理被堵塞的。

当B任务开始后。B占用1-8个线程，队列堵塞27个，后来的A的任务每隔10分钟提交35个任务，由于B任务持续60分钟左右才执行完成，则队列会堵塞，27+60/10 *35=117个任务

同类C任务开始后，会阻塞 117+240/10 *35=957个，最终导致OOM

解决方法：一个项目中应该对不同的任务创建不同的线程池，避免多个任务共用一个线程池

注意：由此可知，创建线程池时，LinkedBlockingQueue 必须指定阻塞队列的大小！否则线程池往往 maxnumPooLSize没气作用，是个摆设！

阻塞队列有6个种，常见3种如下：

ArrayBlockingQueue
LinkedBlockingQueue 默认大小 Integer.max
PriorityBlockingQueue 默认大小11，优先级按 compareTo方法排序

71、通用的简易网络客户端模板

场景：经常调用第三方服务、无非是url、请求头设置（有时候需要将密码设置进请求头）、请求参数共3个组成，自己编写总是随心所欲没有多少规范，使用的也比较原生，因此想找应该通用的工具类，代码如下：

构建请求函数：


    public static HttpRequest httpRequest(String uri, String key, String method, String contents) {
        contents = contents == null ? "" : contents;
        var builder = HttpRequest.newBuilder();
        builder.uri(URI.create(url));
        builder.setHeader("content-type", "application/json");
        builder.setHeader("api-key", key);
 
        switch (method) {
            case "GET":
                builder = builder.GET();
                break;
            case "HEAD":
                builder = builder.GET();
                break;
            case "DELETE":
                builder = builder.DELETE();
                break;
            case "PUT":
                builder = builder.PUT(HttpRequest.BodyPublishers.ofString(contents));
                break;
            case "POST":
                builder = builder.POST(HttpRequest.BodyPublishers.ofString(contents));
                break;
            default:
                throw new IllegalArgumentException(String.format("Can't create request for method '%s'", method));
        }
        return builder.build();
    }

发起请求：


    private final static HttpClient client = HttpClient.newHttpClient();//全局变量
 
    private static HttpResponse<String> sendRequest(HttpRequest request) throws IOException, InterruptedException {
        log.info(String.format("%s: %s", request.method(), request.uri()));
        return client.send(request, HttpResponse.BodyHandlers.ofString());
    }

响应情况：


    public static boolean isSuccessResponse(HttpResponse<String> response) {
        try {
            int responseCode = response.statusCode();
 
            log.info("\n Response code = " + responseCode);
 
            if (responseCode == HttpURLConnection.HTTP_OK || responseCode == HttpURLConnection.HTTP_ACCEPTED
                    || responseCode == HttpURLConnection.HTTP_NO_CONTENT || responseCode == HttpURLConnection.HTTP_CREATED) {
                return true;
            }
 
            // We got an error
            var msg = response.body();
            if (msg != null) {
                log.error(String.format("\n MESSAGE: %s", msg));
            }
 
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

//最终调用示例

72、线程安全的List

场景：多个线程操作同一个全局变量list时，需要使用线程安全的list

线程安全的三种办法：

①Vector
②Collections.synchronizedList()
③CopyOnWriteArrayList.

其中，CopyOnWriteArrayList效率最高，其原理是对Arraylist操作前，先拷贝，再进行增删，增删后，再把原指针指向最新的数组对象。因为涉及到创建、拷贝对象，所以适合读多写少的情况

文章参考：(129条消息) 三种线程安全的List_橙不甜橘不酸的博客-CSDN博客_线程安全list

73、比较两个list中的元素是否相等，以比较两个集合是否相等

关键字：集合比较、对象比较

场景：新老脚本改造，需要对比两个数据库的记录是否相等，因此需要分别连接两个数据库，查询出后，对记录进行比较。部分字段又不想参与比较，如id、create_time这些无意义的比较想忽略

思路：集合中的元素，原本可以重写每个类的compare（）方法，但是只能通用一直类型的，既然需要大范围的调用，排除该方法。考虑到 toSting（）方法，比较每个对象的toString即可

解决：思想对象转map，移除不参与比较的字段，再用toString（），进行比较


package com.XXX.comparedata.utils;
 
 
import com.baomidou.mybatisplus.core.toolkit.BeanUtils;
import org.jetbrains.annotations.NotNull;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
 
public class CompareListData<T> {
 
    public boolean compare(List<T> list1, List<T> list2) {
        if (list1.size() != list2.size()) {
            return false;
        }
       //list中的元素转换成map
        List<Map<String, Object>> src = getMapList(list1);
        List<Map<String, Object>> tag = getMapList(list2);
        //比较两个map集合是否一致
        return Objects.deepEquals(src, tag);
    }
 
    @NotNull
    private List<Map<String, Object>> getMapList(List<T> list) {
        List<Map<String, Object>> arrayList = new ArrayList<>();
        list.forEach(t -> {
            //Map<String, Object> map = BeanUtils.beanToMap(t);//该方法会改变源对象
            Map<String, Object> map = JSONObject.parseObject(JSONObject.toJSONString(t), Map.class);
            //移除这些值（改map不可变，所以采用值覆盖的方式）
            if(map.get("createTime")!=null){
                map.put("createTime",null);
            }
            if(map.get("updateTime")!=null){
                map.put("updateTime",null);
            }
            if(map.get("id")!=null){
                map.put("id",null);
            }
            arrayList.add(map);
        });
        return arrayList;
    }
 
 
}

74、获取符合正则表达式的字符串集合

关键词：工具，数据提取

解决：


  private Set<Integer> getInfoByReg(String s, String regex) {
        Set<Integer> imagesIdList = new HashSet<>();
        Pattern pattern = Pattern.compile(regex);
 
        java.util.regex.Matcher matcher = pattern.matcher(s);
        while (matcher.find()) {
            System.out.println(matcher.group(1));
            imagesIdList.add(Integer.parseInt(matcher.group(1).replace("\"", "")));
        }
        return imagesIdList;
    }

75、java中的基础知识点

关键字：技巧、效率

函数的参数不能设置默认值，但可以通过重载进行实现
事务的本质是原子性，虽然他的特点有4个：一致性、隔离性、原子性、持久性。
1. 在读写分离时，如果某个函数开启了事务，该函数涉及到的一切增删改查将都会在主库（默认写）中执行，在调试程序时需要关闭该事务，以方便调试持续，查就会一定在从库，增删改一定在主库执行。读写分离似乎能够找到整个流程是否存在增删改的操作，以便在最初查询时就选主库或从库（但判断条件后的增删改查它好像选的不一定对！）

76、RabbitMq知识点

rabitMq的概念关系：

虚拟机上有多个交换机、每个交换机上有多个队列.，虚拟机类似于命名空间的作用

rabbitMq交换机的3种类型：topic、fanout、direct,这么多类型是为了各种匹配队列

当交换机类型是topic时使用注解监听：直接指名队列即可

@RabbitListener(queues = {"队列名称"}, containerFactory = "occContainerFactory", concurrency = "1")

当交换机类型是direct时，使用注解监听：


   @RabbitListener(containerFactory = "XXXContainerFactory",
           bindings = {@QueueBinding(
                   value = @Queue("queueName"),
                   exchange = @Exchange(value = "XXXexchange"),
                   key = {"路由key"}
           )})

扩展：假如 AAExchange 已经绑定了队列A，现在想让消息也复制一份发送到队列B的做法：

①新建队列B②将队列别绑定到交换机AAExchange，并绑定和队列A的路由key一样的key

如下：

77、项目结构-经验

场景：项目越来越大代码越来越难维护，虽然一直本着 3层的结构进行（如下：）开发，但每个人开发人员理解和接触的层名称不太一样。

演化-1版本：

controller---->service----->dao

解释：早期使用mybatis的xml编写放在了 mapper中或使用hibernate，查数据的定义函数放在了dao层中，每个表在dao中都唯一对应，service层却与数据库中的表不在一一对应，可能会注入多个dao，整合好后再返回数据即可。

演化-2版本

controller--->service---->mapper

解释：随着mybatis-plus的使用，越来越多的sql不再写在mapper.xml中，使用代码生成器会生成每个数据库表对应的一个service类，其实这个虽然叫service 但本质上就是版本1 中的dao层，于是有出现概念模糊的，有时候会把一个复杂的业务写在某个表对应的service中，导致后期维护越来越难！！，这也是项目维护的痛点

演化-3版本

鉴于版本2，于是出现

controller----->bus----->service----->mapper

解释：bus层用来放复杂的业务（涉及到2+张表以上的查询，因为该层某类要注入2+个以上的 service类），这样就只需要在sevice层中进行lamba的简单查询语句即可，以便后期需求复用。

总结：随着mybatis-plus和jdk的升级，淡化掉了dao层或mapper层，本质一直都是三层结构，尽量本着：操作数据库的类职能单一，不易复用的代码才是真的的业务层

形如以下mapper.selectLisy()查询就不应该出现在逻辑代码中（因为下下面还有map的操作等）,

这样写，以后有人使用查询还要再写一遍！

应该是

使用某个表对应的service.XXXX()；该XXX方法的实现在，该表对应的service中：

：

78、nacos的项目中引用的值

关键词：开关、naocs刷新

场景：项目代码部署后，不想来回部署项目，而实现if esle之类的代码生效，这时候可以使用nacos配置中心的功能

方案1实现：

①naocs的该项目的配置文件夹中配置了 AA=true

②类头上标记刷新注解：@RefreshScope

③引用naocs的变量：@Value（"${AA:true}"） //可以设置默认值如下：


import org.springframework.cloud.context.config.annotation.RefreshScope;
 
 
@RefreshScope  //标记这个文件的值会刷新
@Compent
class aaa{
 
    //引用naocs中的变量
    @Value("${AA}")
    pribate Boolean aaaa;
 
    public void sss（）{
        //业务代码
        if（aaaa）{
            //todo1
        }esle{
            //todo2    
        }
 
    }
}

方案2实现：推荐（遇到一次方案1不生效，即使改了naocs的变量值，控制台打印了AA change了但值就是没变化）

新创建配置类，该类只有各种naocs上的变量,如下：

使用值的地方用 bean注入的方式：


@Auowire
 
priavte  NacosConfig  naocos；
 
 
。。。。。
Boolean = nacos.getBasic();
。。。。

79、idea必装插件：

为了提高开发效率，工具的使用贼方便

①界面主题：Material Theme Ui 选Moonlight主题

②MyBatisX

③GitToolBox 点击某行代码，显示代码谁某时写的

④Grep Console 方便看控制台日志，可以自定义设置颜色

⑤Maven Helper 能够查看maven的jar依赖、冲突

⑥ SequenceDiahram 对函数右键选择后，生成调用链，方便理解和阅读

⑦Translation 翻译

⑧Github Copilot （Ai代码机器人，收费，淘宝50认证学生一年免费）

80、工具类的使用

java项目中，一般都有util包，用于存放自定义的工具类，为了避免重复造轮子，且自己写的工具类还可能有bug.
事实上很多hutool、Guava、Apache Commons包已经给我们提供了各类工具，
每当自己想创建一个工具类时，记得先去看看hutool中是否含有，或者第三方工具包已经含有

由于文字太大：分2篇

(146条消息) 开发中遇到的问题和经验记录 ------- 后端篇（2）_飞花落雨的博客-CSDN博客

81、细节bug

①集合判空不要用Objects.isNull(集合)，因为集合元素为0个的结果是为假

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/393753

开发中遇到的问题和经验 记录 ------- 后端篇_后端服务器一些常见的问题及处理

1、 技巧：向spring注入对象：@configuration 的使用：