脱坑笔记

MySQL中没有设置正确的时区

pojo需要实现Serializable

注意使用插入语句时候看看column是否为非空

注意springboot中controller只能位于springboot启动类的子包之下。

使用MySQL时候的URL：jdbc:mysql://localhost:3306/tensquare_base

mybatis配置的时候是和spring处在同一级的

今天照例写上自己遇到的坑

首先String类型的是使用双引号  ""  包括的，char类型的使用的是单引号  ' '

在剑指offer上面写了个求解1到n中所有数字中1出现的个数时候，在下面的黄色部分出现问题，这里应该注意，使用同一个变量的范围作为判断条件的时候注意，if中的条件语句要从小的向大的写。（惭愧的是，自己花两个多小时写出来的，结果有人几行搞定，路漫漫啊）

public int NumberOf1Between1AndN_Solution(int n) {
        int temp=0;
        int sum=0;
        int len=Integer.toString(n).length();
        int den= (int) Math.pow(10, len-1);
        if(n<1) {
            return 0;
        }
        else if(n<10) {
            return 1;
        }
        temp=n/den;
        sum=(--len)*temp*den/10;
        if (temp==1){
            sum+=n%den+1;
        }else{
            sum+=den;
        }
        return sum+NumberOf1Between1AndN_Solution(n%den);
    }

springboot测试的时候出现出现 Failed to load ApplicationContext 的异常

注意需要在启动类上加上

@EnableAutoConfiguration(exclude = {DataSourceAutoConfiguration.class})

关上springboot的数据源自动配置，如果不关上，并且配置问价中没有就会出现错误。

今天遇到一个问题就是Arrays.asList()这个函数只能接受对象构成的数组，基本数据类型构成的数组是不可以用的。

 
 

 数组一旦设定大小，他的.length实惠求其数组的长度，并不是数组里面有数的长度，因为数组中即使没赋值，其默认的初始值都是零

 

任何被设置初始大小的数组都是不为null的

今天写一个牛客网上面的编程题，犯了一个最不应该犯的错误

String中的“equals()”和“==”，自己像傻子一样一直使用==判断两个的地址，在这里顺便复习一下String中的常量池。

昨天出现springboot和eureka结合时候出现个问题，

程序毫无任何错误输出的情况下结束进程，控制台打印

process exit with code 1

百度了好久没找到，最后在GitHub上找到了，老外自己debug出来的，看来以后自己要学着找bug

最后按照老外的加上下面日志包，程序奇迹般的好使了

<dependency>
    <groupId>net.logstash.logback</groupId>
    <artifactId>logstash-logback-encoder</artifactId>
    <version>4.7</version>
</dependency>

但是回头想去找错误的时候，将这个依赖注释掉重启服务，尴尬的是服务没毛病，重启了还是一样正常，我只记得上一步自己在maven工程中加入了一个.iml文件。因为工程不知道为什么没生成这个文件，里面存放的是maven的配置信息。

老外debug显示是相关的日志包不对，将springboot中的日志包去除，自己手动加上日志包。相关的配置如下

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-hateoas</artifactId>
            <version>${spring.boot.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>ch.qos.logback</groupId>
                    <artifactId>logback-core</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>ch.qos.logback</groupId>
                    <artifactId>logback-classic</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-batch</artifactId>
            <version>${spring.boot.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>ch.qos.logback</groupId>
                    <artifactId>logback-core</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>ch.qos.logback</groupId>
                    <artifactId>logback-classic</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-access</artifactId>
            <version>1.2.3</version>
        </dependency>
        <dependency>
            <groupId>net.logstash.logback</groupId>
            <artifactId>logstash-logback-encoder</artifactId>
            <version>4.11</version>
        </dependency>
</dependencies>

最后贴上老外的地址  https://github.com/logstash/logstash-logback-encoder/issues/243

今天使用eureka时候出现一个问题就是在使用json反序列化的时候必须有默认的构造函数，否则就会报错，错误忘记截图了，下次一定先贴截图

generate-ddl生成表结构

有个就是所有的类在声明的时候必须初始化，否则没有办法使用

因为查询结果是空，friend任然是个空指针，必须初始化，才能在下面使用

拦截器的设置

@Component
public class JwtIntercepter implements HandlerInterceptor {


    @Autowired
private JwtUtil jwtUtil;

    @Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        String header=request.getHeader("Authorization");

        if(header!=null&&!"".equals(header)&&header.startsWith("Bearer ")){
            String token=header.substring(7);
            try{

                Claims claims=jwtUtil.parseJWT(token);
                String roles= (String) claims.get("roles");
                if(roles!=""&&roles.equals("admin")){
                    request.setAttribute("claims_admin",claims);
                }
                if(roles!=null&&roles.equals("user")){
                    request.setAttribute("claims_user",claims);
                }
            }catch(Exception e){
                e.printStackTrace();
            }
            return true;
        }
        return false;
    }
}

注意拦截器最后的设置。重写方法需要注意是不是写错了

注意在循环或者递归的时候一定注意对象是否为空，添加对应防止对象是空情况下的处理 

public class Solution {


    private boolean funSymmetric(TreeNode l,TreeNode r){
        if(l==null&&r==null){
            return true;
        }
        if(l==null||r==null){
            return false;
        }
        if(l.val!=r.val){
            return false;
        }else{
            return funSymmetric(l.left,r.right)&&funSymmetric(l.right,r.left);
        }
    }
    boolean isSymmetrical(TreeNode pRoot)
    {
        if(pRoot==null){
            return true;
        }
        return funSymmetric(pRoot.left,pRoot.right);

    }
}

 使用zuul网关的时候注意需要在添加的过滤器上添加@Component注解

一个关于maven的错误 ，出现红色波浪线(unresolved dependency),解决办法之一就是删除pom文件中的依赖，在重新写入，对于自己写的工程需要使用mvn clean一下在mvn install一下。还有一个在搜索问题的时候有人建议导入工程时候使用open，在Structure中在设置，如果你是直接复制的项目文件夹  你要点 open  不要点 import project。  原因好像是如果 点了import project按照向导设置到最后，就会多出一个main工程，所有的依赖都会在main工程下找，main工程是你刚创建的肯定是空的，所以肯定会报错了。  要确实想import project,你需要去Project Structure 下的Modules里，把你原项目下的所有包都加进main下就好了

看ThreadPoolExecutor源码的时候在addWorker()函数遇到一个循环的问题

    private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        for (;;) {
            int c = ctl.get();
            int rs = runStateOf(c);

            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                if (compareAndIncrementWorkerCount(c))
                    break retry;
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
                // else CAS failed due to workerCount change; retry inner loop
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                final ReentrantLock mainLock = this.mainLock;
                mainLock.lock();
                try {
                    // Recheck while holding lock.
                    // Back out on ThreadFactory failure or if
                    // shut down before lock acquired.
                    int rs = runStateOf(ctl.get());

                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                        workers.add(w);
                        int s = workers.size();
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                if (workerAdded) {
                    t.start();
                    workerStarted = true;
                }
            }
        } finally {
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
    }

这里应该注意上面的retry：这个标签是用来跳出外层循环的。因为本身的break和continue只能跳出一层循环。






        

	      

	    

	  

	  

	    
      
        【推广】
        免费学中医，健康全家人
      
	  

    

    

          原文地址：https://www.cnblogs.com/feixiangdecainiao/p/10440428.html