Spring 中那些让你爱不释手的代码技巧

Posted Java知音

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring 中那些让你爱不释手的代码技巧相关的知识，希望对你有一定的参考价值。


BeanFactory beanFactory;

BeansException



Person person = (Person) beanFactory.getBean(

实现BeanFactoryAware接口，然后重写setBeanFactory方法，就能从该方法中获取到spring容器对象。


ApplicationContext applicationContext;

BeansException



Person person = (Person) applicationContext.getBean(


实现ApplicationContextAware接口，然后重写setApplicationContext方法，也能从该方法中获取到spring容器对象。

ApplicationContext applicationContext;



applicationContext = event.getApplicationContext();



Person person = (Person) applicationContext.getBean(


实现ApplicationListener接口，需要注意的是该接口接收的泛型是ContextRefreshedEvent类，然后重写onApplicationEvent方法，也能从该方法中获取到spring容器对象。

此外，不得不提一下Aware接口，它其实是一个空接口，里面不包含任何方法。

它表示已感知的意思，通过这类接口可以获取指定对象，比如：

  • 通过BeanFactoryAware获取BeanFactory
  • 通过ApplicationContextAware获取ApplicationContext
  • 通过BeanNameAware获取BeanName等




    • System.out.println(

    在需要初始化的方法上增加@PostConstruct注解，这样就有初始化的能力。



    Exception
    System.out.println(

    实现InitializingBean接口，重写afterPropertiesSet方法，该方法中可以完成初始化功能。

    这里顺便抛出一个有趣的问题：init-method、PostConstruct 和 InitializingBean 的执行顺序是什么样的？

    决定他们调用顺序的关键代码在AbstractAutowireCapableBeanFactory类的initializeBean方法中。

    这段代码中会先调用BeanPostProcessor的postProcessBeforeInitialization方法，而PostConstruct是通过InitDestroyAnnotationBeanPostProcessor实现的，它就是一个BeanPostProcessor，所以PostConstruct先执行。

    而invokeInitMethods方法中的代码：

    决定了先调用InitializingBean，再调用init-method。

    所以得出结论，他们的调用顺序是：



    ThreadLocal THREAD_LOCAL_SCOPE = ThreadLocal();

    Object
    Object value = THREAD_LOCAL_SCOPE.get();
    (value != value;


    Object object = objectFactory.getObject();
    THREAD_LOCAL_SCOPE.set(object);
    object;


    Object
    THREAD_LOCAL_SCOPE.remove();






    Object


    String


    第二步将新定义的Scope注入到spring容器中：



           BeansException 
            beanFactory.registerScope(ThreadLocalScope());

    第三步使用新定义的Scope：



    Object Exception
    String data1 = buildData1();
    String data2 = buildData2();
    buildData3(data1, data2);


    String


    String


    String
    data1 + data2;



    Class<?> getObjectType()


    获取FactoryBean实例对象：


        BeanFactory beanFactory;

           BeansException 
               

        
            Object myFactoryBean = beanFactory.getBean(       System.out.println(myFactoryBean);
            Object myFactoryBean1 = beanFactory.getBean(       System.out.println(myFactoryBean1);

  • getBean("myFactoryBean");获取的是MyFactoryBeanService类中getObject方法返回的对象，

  • getBean("&myFactoryBean");获取的才是MyFactoryBean对象。



    • Long id;
    String name;
    Date registerDate;

    第二步，实现Converter接口：

       SimpleDateFormat simpleDateFormat = SimpleDateFormat(      Date 
            (source != && !           
                    simpleDateFormat.parse(source);
                 (ParseException e) 
                    e.printStackTrace();

    第三步，将新定义的类型转换器注入到spring容器中：



           
            registry.addConverter(DateConverter());


    第四步，调用接口



           String

    请求接口时User对象中registerDate字段会被自动转换成Date类型。

    等web对象实例。

    spring mvc拦截器的顶层接口是：HandlerInterceptor，包含三个方法：

  • preHandle 目标方法执行前执行
  • postHandle 目标方法执行后执行
  • afterCompletion 请求完成时执行

    • 为了方便我们一般情况会用

    Exception
    String requestUrl = request.getRequestURI();
    (checkAuth(requestUrl))





    System.out.println(


    第二步，将该拦截器注册到spring容器：


     
           AuthInterceptor 
            AuthInterceptor();
        

           
            registry.addInterceptor(AuthInterceptor());

    第三步，在请求接口时spring mvc通过该拦截器，能够自动拦截该接口，并且校验权限。

    该拦截器其实相对来说，比较简单，可以在DispatcherServlet类的doDispatch方法中看到调用过程：

    顺便说一句，这里只讲了spring mvc的拦截器，并
    ServletException



    IOException, ServletException
    System.out.println( chain.doFilter(request, response);
    System.out.println(





    第二步，注册LogFilter：



           LogFilter 
            LogFilter();

    注意，这里用了@ConditionalOnWebApplication注解，没有直接使用@Configuration注解。

    第三步，定义开关@EnableLog注解：

    @


    第四步，只需在springboot启动类加上@EnableLog注解即可开启LogFilter记录请求和响应日志的功能。



    ClientHttpResponse IOException
    request.getHeaders().set( execution.execute(request, body);


    第二步，定义配置类：



           RestTemplate 
            RestTemplate restTemplate = RestTemplate();
            restTemplate.setInterceptors(Collections.singletonList(restTemplateInterceptor()));
            restTemplate;
        

           RestTemplateInterceptor 
            RestTemplateInterceptor();

    其中MdcUtil其实是利用MDC工具在ThreadLocal中存储和获取traceId



        String TRACE_ID =    String 
            MDC.get(TRACE_ID);
        

        
            MDC.put(TRACE_ID, value);

    当然，这个例子中没有演示MdcUtil类的add方法具体调的地方，我们可以在filter中执行接口方法之前，生成traceId，调用MdcUtil类的add方法添加到MDC中，然后在同一个请求的其他地方就能通过MdcUtil类的get方法获取到该traceId。



    String
    a = /

    如果不做任何处理请求add接口结果直接报错：

    what？用户能直接看到错误信息？

    这种交互方式给用户的体验非常差，为了解决这个问题，我们通常会在接口中捕获异常：

        String 
            String result =        
                a = /         (Exception e) 
                result =        
            result;

    接口改造后，出现异常时会提示：“数据异常”，对用户来说更友好。

    看起来挺不错的，但是有问题。。。

    如果只是一个接口还好，但是如果项目中有成百上千个接口，都要加上异常捕获代码吗？

    答案是否定的，这时全局异常处理就派上用场了：RestControllerAdvice。



                  (e ArithmeticException) 
                       
            (e Exception)

    只需在handleException方法中处理异常情况，业务接口中可以放心使用，不再需要捕获异常（有人统一处理了）。真是爽歪歪。




    System.out.println(


    MyThread().start();


    1. 实现Runable接口

           
            System.out.println(   

        
            Thread(MyWork()).start();

    1. 使用线程池


        ExecutorService executorService = ThreadPoolExecutor(ArrayBlockingQueue<>(   

                   
                System.out.println(       
        

        
            
                executorService.submit(MyThreadPool.Work());
             
                executorService.shutdown();

    这三种实现异步的方法不能说不好，但是spring已经帮我们抽取了一些公共的地方，我们无需再继承Thread类或实现Runable接口，它都搞定了。

    如何spring异步功能呢？

    第一步，springboot项目启动类上加@EnableAsync注解。



        
            SpringApplicationBuilder(Application

    第二步，在需要使用异步的方法上加上@Async注解：



           String 
            System.out.println(

    然后在使用的地方调用一下：personService.get();就拥有了异步功能，是不是很神奇。

    默认情况下，spring会为我们的异步方法创建一个线程去执行，如果该方法被调用次数非常多的话，需要创建大量的线程，会导致资源浪费。

    这时，我们可以定义一个线程池，异步方法将会被自动提交到线程池中执行。



           corePoolSize;

           maxPoolSize;

           queueCapacity;

           keepAliveSeconds;

           String threadNamePrefix;

           Executor 
            ThreadPoolTaskExecutor executor = ThreadPoolTaskExecutor();
            executor.setCorePoolSize(corePoolSize);
            executor.setMaxPoolSize(maxPoolSize);
            executor.setQueueCapacity(queueCapacity);
            executor.setKeepAliveSeconds(keepAliveSeconds);
            executor.setThreadNamePrefix(threadNamePrefix);
            executor.setRejectedExecutionHandler(ThreadPoolExecutor.CallerRunsPolicy());
            executor.initialize();
            executor;

    spring异步的核心方法：

    根据返回值不同，处理情况也不太一样，具体分为如下情况：

    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
    </dependency>
    <dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>
    CacheManager CaffeineCacheManager cacheManager = CaffeineCacheManager();
    Caffeine<Object, Object> caffeine = Caffeine.newBuilder()
    .expireAfterWrite( .maximumSize( cacheManager.setCaffeine(caffeine);
    cacheManager;


    第三步，使用Cacheable注解获取数据


       
           CategoryModel 
           getCategoryByType(type);
       

       CategoryModel 
           System.out.println(+ type +       CategoryModel categoryModel = CategoryModel();
           categoryModel.setId(      categoryModel.setParentId(      categoryModel.setName(      categoryModel.setLevel(      categoryModel;

    调用categoryService.getCategory()方法时，先从caffine缓存中获取数据，如果能够获取到数据则直接返回该数据，不会进入方法体。如果不能获取到数据，则直接方法体中的代码获取到数据，然后放到caffine缓存中。

    唠唠家常

    spring中不错的功能其实还有很多，比如：BeanPostProcessor,BeanFactoryPostProcessor,AOP,动态数据源，ImportSelector等等。我原本打算一篇文章写全的，但是有两件事情改变了我的注意：

    1. 有个大佬原本打算转载我文章的，却因为篇幅太长一直没有保存成功。
    2. 最近经常加班，真的没多少时间写文章，晚上还要带娃，喂奶，换尿布，其实挺累的。

    END

    推荐好文

    强大，10k+点赞的 SpringBoot 后台管理系统竟然出了详细教程！
    分享一套基于SpringBoot和Vue的企业级中后台开源项目，代码很规范！
    能挣钱的，开源 SpringBoot 商城系统，功能超全，超漂亮！

    spring中那些让你爱不释手的代码技巧（spring的故事续集）

    前言

    上一篇文章发表之后，受到了不少读者的好评，很多读者都在期待续集。今天非常高兴的通知大家，你们要的续集来了。本文继续总结我认为spring中还不错的知识点，希望对您有所帮助。

    一. @Conditional的强大之处

    不知道你们有没有遇到过这些问题：

    1. 某个功能需要根据项目中有没有某个jar判断是否开启该功能。

    2. 某个bean的实例化需要先判断另一个bean有没有实例化，再判断是否实例化自己。

    3. 某个功能是否开启，在配置文件中有个参数可以对它进行控制。

    如果你有遇到过上述这些问题，那么恭喜你，本节内容非常适合你。

    @ConditionalOnClass

    问题1可以用@ConditionalOnClass注解解决，代码如下：

    public  class A {  
}  
  
public  class B {  
}  
  
@ConditionalOnClass(B.class)  
@Configuration  
public class TestConfiguration {  
  
    @Bean  
    public A a() {  
      return    new A();  
    }  
}

    如果项目中存在B类，则会实例化A类。如果不存在B类，则不会实例化A类。

    有人可能会问：不是判断有没有某个jar吗？怎么现在判断某个类了？

    ❝

    直接判断有没有该jar下的某个关键类更简单。

    ❞

    这个注解有个升级版的应用场景：比如common工程中写了一个发消息的工具类mqTemplate，业务工程引用了common工程，只需再引入消息中间件，比如rocketmq的jar包，就能开启mqTemplate的功能。而如果有另一个业务工程，通用引用了common工程，如果不需要发消息的功能，不引入rocketmq的jar包即可。

    这个注解的功能还是挺实用的吧？

    @ConditionalOnBean

    问题2可以通过@ConditionalOnBean注解解决，代码如下：

    @Configuration  
public  class TestConfiguration {  
  
    @Bean  
    public B b() {  
        return  new B();  
    }  
  
    @ConditionalOnBean(name="b")  
    @Bean  
    public A a() {  
      return    new A();  
    }  
}

    实例A只有在实例B存在时，才能实例化。

    @ConditionalOnProperty

    问题3可以通过@ConditionalOnProperty注解解决，代码如下：

    @ConditionalOnProperty(prefix = "demo",name="enable", havingValue = "true",matchIfMissing=true )  
@Configuration  
public  class TestConfiguration {  
  
    @Bean  
    public A a() {  
      return    new A();  
    }  
}

    在applicationContext.properties文件中配置参数：

    demo.enable=false

    各参数含义：

    这个功能可以作为开关，相比EnableXXX注解的开关更优雅，因为它可以通过参数配置是否开启，而EnableXXX注解的开关需要在代码中硬编码开启或关闭。

    如果你觉得自己学习效率低，缺乏正确的指导，可以加入资源丰富，学习氛围浓厚的技术圈一起学习交流吧！
    [Java架构群]
    群内有许多来自一线的技术大牛，也有在小厂或外包公司奋斗的码农，我们致力打造一个平等，高质量的JAVA交流圈子，不一定能短期就让每个人的技术突飞猛进，但从长远来说，眼光，格局，长远发展的方向才是最重要的。

    其他的Conditional注解

    当然，spring用得比较多的Conditional注解还有：ConditionalOnMissingClass、ConditionalOnMissingBean、ConditionalOnWebApplication等。

    下面用一张图整体认识一下@Conditional家族。

    自定义Conditional

    说实话，个人认为springboot自带的Conditional系列已经可以满足我们绝大多数的需求了。但如果你有比较特殊的场景，也可以自定义自定义Conditional。

    第一步，自定义注解：

    @Conditional(MyCondition.class)  
@Retention(RetentionPolicy.RUNTIME)  
@Target({ElementType.TYPE, ElementType.METHOD})  
@Documented  
public  @interface MyConditionOnProperty {  
    String name() default "";  
  
    String havingValue() default "";  
}

    第二步，实现Condition接口：

    public  class MyCondition implements Condition {  
    @Override  
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {  
        System.out.println("实现自定义逻辑");  
        return  false;  
    }  
}

    第三步，使用@MyConditionOnProperty注解。

    Conditional的奥秘就藏在ConfigurationClassParser类的processConfigurationClass方法中：

    这个方法逻辑不复杂：

    1. 先判断有没有使用Conditional注解，如果没有直接返回false

    2. 收集condition到集合中

    3. 按order排序该集合

    4. 遍历该集合，循环调用condition的matchs方法。

    二. 如何妙用@Import？

    有时我们需要在某个配置类中引入另外一些类，被引入的类也加到spring容器中。这时可以使用@Import注解完成这个功能。

    如果你看过它的源码会发现，引入的类支持三种不同类型。

    但是我认为最好将普通类和@Configuration注解的配置类分开讲解，所以列了四种不同类型：

    普通类

    这种引入方式是最简单的，被引入的类会被实例化bean对象。

    public  class A {  
}  
  
@Import(A.class)  
@Configuration  
public class TestConfiguration {  
}

    通过@Import注解引入A类，spring就能自动实例化A对象，然后在需要使用的地方通过@Autowired注解注入即可：

     @Autowired  
private A a;

    是不是挺让人意外的？不用加@Bean注解也能实例化bean。

    @Configuration注解的配置类

    这种引入方式是最复杂的，因为@Configuration注解还支持多种组合注解，比如：

    public  class A {  
}  
  
public  class B {  
}  
  
@Import(B.class)  
@Configuration  
public class AConfiguration {  
  
    @Bean  
    public A a() {  
        return  new A();  
    }  
}  
  
@Import(AConfiguration.class)  
@Configuration  
public class TestConfiguration {  
}

    通过@Import注解引入@Configuration注解的配置类，会把该配置类相关@Import、@ImportResource、@PropertySource等注解引入的类进行递归，一次性全部引入。

    由于文章篇幅有限不过多介绍了，这里留点悬念，后面会出一篇文章专门介绍@Configuration注解，因为它实在太太太重要了。

    实现ImportSelector接口的类

    这种引入方式需要实现ImportSelector接口：

    public  class AImportSelector implements ImportSelector {  
  
private  static  final String CLASS_NAME = "com.sue.cache.service.test13.A";  
      
 public String[] selectImports(AnnotationMetadata importingClassMetadata) {  
        return  new String[]{CLASS_NAME};  
    }  
}  
  
@Import(AImportSelector.class)  
@Configuration  
public class TestConfiguration {  
}

    这种方式的好处是selectImports方法返回的是数组，意味着可以同时引入多个类，还是非常方便的。

    实现ImportBeanDefinitionRegistrar接口的类

    这种引入方式需要实现ImportBeanDefinitionRegistrar接口：

    public  class AImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {  
    @Override  
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {  
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(A.class);  
        registry.registerBeanDefinition("a", rootBeanDefinition);  
    }  
}  
  
@Import(AImportBeanDefinitionRegistrar.class)  
@Configuration  
public class TestConfiguration {  
}

    这种方式是最灵活的，能在registerBeanDefinitions方法中获取到BeanDefinitionRegistry容器注册对象，可以手动控制BeanDefinition的创建和注册。

    当然@import注解非常人性化，还支持同时引入多种不同类型的类。

    @Import({B.class,AImportBeanDefinitionRegistrar.class})  
@Configuration  
public class TestConfiguration {  
}

    这四种引入类的方式各有千秋，总结如下：

    1. 普通类，用于创建没有特殊要求的bean实例。

    2. @Configuration注解的配置类，用于层层嵌套引入的场景。

    3. 实现ImportSelector接口的类，用于一次性引入多个类的场景，或者可以根据不同的配置决定引入不同类的场景。

    4. 实现ImportBeanDefinitionRegistrar接口的类，主要用于可以手动控制BeanDefinition的创建和注册的场景，它的方法中可以获取BeanDefinitionRegistry注册容器对象。

    在ConfigurationClassParser类的processImports方法中可以看到这三种方式的处理逻辑：

    最后的else方法其实包含了：普通类和@Configuration注解的配置类两种不同的处理逻辑。

    三. @ConfigurationProperties赋值

    我们在项目中使用配置参数是非常常见的场景，比如，我们在配置线程池的时候，需要在applicationContext.propeties文件中定义如下配置：

    thread.pool.corePoolSize=5  
thread.pool.maxPoolSize=10  
thread.pool.queueCapacity=200  
thread.pool.keepAliveSeconds=30

    方法一：通过@Value注解读取这些配置。

    public  class ThreadPoolConfig {  
  
    @Value("${thread.pool.corePoolSize:5}")  
    private  int corePoolSize;  
  
    @Value("${thread.pool.maxPoolSize:10}")  
    private  int maxPoolSize;  
  
    @Value("${thread.pool.queueCapacity:200}")  
    private  int queueCapacity;  
  
    @Value("${thread.pool.keepAliveSeconds:30}")  
    private  int keepAliveSeconds;  
  
    @Value("${thread.pool.threadNamePrefix:ASYNC_}")  
    private String threadNamePrefix;  
  
    @Bean  
    public Executor threadPoolExecutor() {  
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();  
        executor.setCorePoolSize(corePoolSize);  
        executor.setMaxPoolSize(maxPoolSize);  
        executor.setQueueCapacity(queueCapacity);  
        executor.setKeepAliveSeconds(keepAliveSeconds);  
        executor.setThreadNamePrefix(threadNamePrefix);  
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());  
        executor.initialize();  
        return executor;  
    }  
}

    这种方式使用起来非常简单，但建议在使用时都加上:，因为:后面跟的是默认值，比如：@Value("${thread.pool.corePoolSize:5}")，定义的默认核心线程数是5。

    ❝

    假如有这样的场景：business工程下定义了这个ThreadPoolConfig类，api工程引用了business工程，同时job工程也引用了business工程，而ThreadPoolConfig类只想在api工程中使用。这时，如果不配置默认值，job工程启动的时候可能会报错。

    ❞

    如果参数少还好，多的话，需要给每一个参数都加上@Value注解，是不是有点麻烦？

    此外，还有一个问题，@Value注解定义的参数看起来有点分散，不容易辨别哪些参数是一组的。

    这时，@ConfigurationProperties就派上用场了，它是springboot中新加的注解。

    第一步，先定义ThreadPoolProperties类

    @Data  
@Component  
@ConfigurationProperties("thread.pool")  
public  class ThreadPoolProperties {  
  
    private  int corePoolSize;  
    private  int maxPoolSize;  
    private  int queueCapacity;  
    private  int keepAliveSeconds;  
    private String threadNamePrefix;  
}

    第二步，使用ThreadPoolProperties类

    @Configuration  
public  class ThreadPoolConfig {  
  
    @Autowired  
    private ThreadPoolProperties threadPoolProperties;  
  
    @Bean  
    public Executor threadPoolExecutor() {  
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();  
        executor.setCorePoolSize(threadPoolProperties.getCorePoolSize());  
        executor.setMaxPoolSize(threadPoolProperties.getMaxPoolSize());  
        executor.setQueueCapacity(threadPoolProperties.getQueueCapacity());  
        executor.setKeepAliveSeconds(threadPoolProperties.getKeepAliveSeconds());  
        executor.setThreadNamePrefix(threadPoolProperties.getThreadNamePrefix());  
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());  
        executor.initialize();  
        return executor;  
    }  
}

    使用@ConfigurationProperties注解，可以将thread.pool开头的参数直接赋值到ThreadPoolProperties类的同名参数中，这样省去了像@Value注解那样一个个手动去对应的过程。

    这种方式显然要方便很多，我们只需编写xxxProperties类，spring会自动装配参数。此外，不同系列的参数可以定义不同的xxxProperties类，也便于管理，推荐优先使用这种方式。

    它的底层是通过：ConfigurationPropertiesBindingPostProcessor类实现的，该类实现了BeanPostProcessor接口，在postProcessBeforeInitialization方法中解析@ConfigurationProperties注解，并且绑定数据到相应的对象上。

    绑定是通过Binder类的bindObject方法完成的：

    以上这段代码会递归绑定数据，主要考虑了三种情况：

    「此外，友情提醒一下：」

    使用@ConfigurationProperties注解有些场景有问题，比如：在apollo中修改了某个参数，正常情况可以动态更新到@ConfigurationProperties注解定义的xxxProperties类的对象中，但是如果出现比较复杂的对象，比如：

    private Map<String, Map<String,String>>  urls;

    可能动态更新不了。

    这时候该怎么办呢？

    答案是使用ApolloConfigChangeListener监听器自己处理：

    @ConditionalOnClass(com.ctrip.framework.apollo.spring.annotation.EnableApolloConfig.class)  
public class ApolloConfigurationAutoRefresh implements ApplicationContextAware {  
   private ApplicationContext applicationContext;  
     
   @Override  
   public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {  
        this.applicationContext = applicationContext;  
   }  
     
    @ApolloConfigChangeListener  
    private void onChange(ConfigChangeEvent changeEvent{  
        refreshConfig(changeEvent.changedKeys());  
    }  
    private void refreshConfig(Set<String> changedKeys){  
       System.out.println("将变更的参数更新到相应的对象中");  
    }  
}

    四. spring事务要如何避坑？

    spring中的事务功能主要分为：声明式事务和编程式事务。

    声明式事务

    大多数情况下，我们在开发过程中使用更多的可能是声明式事务，即使用@Transactional注解定义的事务，因为它用起来更简单，方便。

    只需在需要执行的事务方法上，加上@Transactional注解就能自动开启事务：

    @Service  
public  class UserService {  
  
    @Autowired  
    private UserMapper userMapper;  
      
    @Transactional  
    public void add(UserModel userModel) {  
        userMapper.insertUser(userModel);  
    }  
}

    这种声明式事务之所以能生效，是因为它的底层使用了AOP，创建了代理对象，调用TransactionInterceptor拦截器实现事务的功能。

    ❝

    spring事务有个特别的地方：它获取的数据库连接放在ThreadLocal中的，也就是说同一个线程中从始至终都能获取同一个数据库连接，可以保证同一个线程中多次数据库操作在同一个事务中执行。

    ❞

    正常情况下是没有问题的，但是如果使用不当，事务会失效，主要原因如下：

    除了上述列举的问题之外，由于@Transactional注解最小粒度是要被定义在方法上，如果有多层的事务方法调用，可能会造成大事务问题。

    所以，建议在实际工作中少用@Transactional注解开启事务。

    编程式事务

    一般情况下编程式事务我们可以通过TransactionTemplate类开启事务功能。有个好消息，就是springboot已经默认实例化好这个对象了，我们能直接在项目中使用。

    @Service  
public  class UserService {  
   @Autowired  
   private TransactionTemplate transactionTemplate;  
     
   ...  
     
   public void save(final User user) {  
         transactionTemplate.execute((status) => {  
            doSameThing...  
            return Boolean.TRUE;  
         })  
   }  
}

    使用TransactionTemplate的编程式事务能避免很多事务失效的问题，但是对大事务问题，不一定能够解决，只是说相对于使用@Transactional注解要好些。

    五. 跨域问题的解决方案

    关于跨域问题，前后端的解决方案还是挺多的，这里我重点说说spring的解决方案，目前有三种：

    一.使用@CrossOrigin注解

    @RequestMapping("/user")  
@RestController  
public  class UserController {  
  
    @CrossOrigin(origins = "http://localhost:8016")  
    @RequestMapping("/getUser")  
    public String getUser(@RequestParam("name") String name) {  
        System.out.println("name:" + name);  
        return  "success";  
    }  
}

    该方案需要在跨域访问的接口上加@CrossOrigin注解，访问规则可以通过注解中的参数控制，控制粒度更细。如果需要跨域访问的接口数量较少，可以使用该方案。

    二.增加全局配置

    @Configuration  
public  class WebConfig implements WebMvcConfigurer {  
  
    @Override  
    public void addCorsMappings(CorsRegistry registry) {  
        registry.addMapping("/**")  
                .allowedOrigins("*")  
                .allowedMethods("GET", "POST")  
                .allowCredentials(true)  
                .maxAge(3600)  
                .allowedHeaders("*");  
  
    }  
}

    该方案需要实现WebMvcConfigurer接口，重写addCorsMappings方法，在该方法中定义跨域访问的规则。这是一个全局的配置，可以应用于所有接口。

    三.自定义过滤器

    @WebFilter("corsFilter")  
@Configuration  
public  class CorsFilter implements Filter {  
  
    @Override  
    public void init(FilterConfig filterConfig) throws ServletException {  
  
    }  
  
    @Override  
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {  
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;  
        httpServletResponse.setHeader("Access-Control-Allow-Origin", "*");  
        httpServletResponse.setHeader("Access-Control-Allow-Methods", "POST, GET");  
        httpServletResponse.setHeader("Access-Control-Max-Age", "3600");  
        httpServletResponse.setHeader("Access-Control-Allow-Headers", "x-requested-with");  
        chain.doFilter(request, response);  
    }  
  
    @Override  
    public void destroy() {  
  
    }  
}

    该方案通过在请求的header中增加Access-Control-Allow-Origin等参数解决跨域问题。

    顺便说一下，使用@CrossOrigin注解 和 实现WebMvcConfigurer接口的方案，spring在底层最终都会调用到DefaultCorsProcessor类的handleInternal方法：

    最终三种方案殊途同归，都会往header中添加跨域需要参数，只是实现形式不一样而已。

    六. 如何自定义starter

    以前在没有使用starter时，我们在项目中需要引入新功能，步骤一般是这样的：

    以上这种方式会带来三个问题：

    1. 如果依赖包较多，找起来很麻烦，容易找错，而且要花很多时间。

    2. 各依赖包之间可能会存在版本兼容性问题，项目引入这些jar包后，可能没法正常启动。

    3. 如果有些参数没有配好，启动服务也会报错，没有默认配置。

    「为了解决这些问题，springboot的starter机制应运而生」。

    starter机制带来这些好处：

    1. 它能启动相应的默认配置。

    2. 它能够管理所需依赖，摆脱了需要到处找依赖 和 兼容性问题的困扰。

    3. 自动发现机制，将spring.factories文件中配置的类，自动注入到spring容器中。

    4. 遵循“约定大于配置”的理念。

    在业务工程中只需引入starter包，就能使用它的功能，太爽了。

    下面用一张图，总结starter的几个要素：

    接下来我们一起实战，定义一个自己的starter。

    第一步，创建id-generate-starter工程：其中的pom.xml配置如下：

    <?xml version="1.0" encoding="UTF-8"?>  
  
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
    <modelVersion>4.0.0</modelVersion>  
  
    <version>1.3.1</version>  
    <groupId>com.sue</groupId>  
    <artifactId>id-generate-spring-boot-starter</artifactId>  
    <name>id-generate-spring-boot-starter</name>  
    <dependencies>  
        <dependency>  
            <groupId>com.sue</groupId>  
            <artifactId>id-generate-spring-boot-autoconfigure</artifactId>  
            <version>1.3.1</version>  
        </dependency>  
    </dependencies>  
</project>

    第二步，创建id-generate-spring-boot-autoconfigure工程：该项目当中包含：

    <?xml version="1.0" encoding="UTF-8"?>  
  
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
  
    <parent>  
        <groupId>org.springframework.boot</groupId>  
        <artifactId>spring-boot-starter-parent</artifactId>  
        <version>2.0.4.RELEASE</version>  
    </parent>  
    <modelVersion>4.0.0</modelVersion>  
    <version>1.3.1</version>  
    <groupId>com.sue</groupId>  
    <artifactId>id-generate-spring-boot-autoconfigure</artifactId>  
    <name>id-generate-spring-boot-autoconfigure</name>  
  
    <dependencies>  
        <dependency>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter</artifactId>  
        </dependency>  
  
        <dependency>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-autoconfigure</artifactId>  
        </dependency>  
  
        <dependency>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-configuration-processor</artifactId>  
            <optional>true</optional>  
        </dependency>  
    </dependencies>  
  
    <build>  
        <plugins>  
            <plugin>  
                <groupId>org.apache.maven.plugins</groupId>  
                <artifactId>maven-compiler-plugin</artifactId>  
                <configuration>  
                    <source>1.8</source>  
                    <target>1.8</target>  
                </configuration>  
            </plugin>  
        </plugins>  
    </build>  
</project>

    spring.factories配置如下：

    org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.sue.IdGenerateAutoConfiguration

    IdGenerateAutoConfiguration类：

    @ConditionalOnClass(IdProperties.class)  
@EnableConfigurationProperties(IdProperties.class)  
@Configuration  
public class IdGenerateAutoConfiguration {  
  
    @Autowired  
    private IdProperties properties;  
  
    @Bean  
    public IdGenerateService idGenerateService() {  
        return  new IdGenerateService(properties.getWorkId());  
    }  
}

    IdGenerateService类：

    public  class IdGenerateService {  
  
    private Long workId;  
  
    public IdGenerateService(Long workId) {  
        this.workId = workId;  
    }  
  
    public Long generate() {  
        return  new Random().nextInt(100) + this.workId;  
    }  
}

    IdProperties类：

    @ConfigurationProperties(prefix = IdProperties.PREFIX)  
public  class IdProperties {  
  
  
    public  static  final String PREFIX = "sue";  
  
    private Long workId;  
  
    public Long getWorkId() {  
        return workId;  
    }  
  
    public void setWorkId(Long workId) {  
        this.workId = workId;  
    }  
}

    这样在业务项目中引入相关依赖:

    <dependency>  
      <groupId>com.sue</groupId>  
      <artifactId>id-generate-spring-boot-starter</artifactId>  
      <version>1.3.1</version>  
</dependency>

    就能使用注入使用IdGenerateService的功能了

     @Autowired  
  private IdGenerateService idGenerateService;

    完美。

    七.项目启动时的附加功能

    有时候我们需要在项目启动时定制化一些附加功能，比如：加载一些系统参数、完成初始化、预热本地缓存等，该怎么办呢？

    好消息是springboot提供了：

    这两个接口帮助我们实现以上需求。

    它们的用法还是挺简单的，以ApplicationRunner接口为例：

    @Component  
public  class TestRunner implements ApplicationRunner {  
  
    @Autowired  
    private LoadDataService loadDataService;  
  
    public void run(ApplicationArguments args) throws Exception {  
        loadDataService.load();  
    }  
      
}

    实现ApplicationRunner接口，重写run方法，在该方法中实现自己定制化需求。

    如果项目中有多个类实现了ApplicationRunner接口，他们的执行顺序要怎么指定呢？

    答案是使用@Order(n)注解，n的值越小越先执行。当然也可以通过@Priority注解指定顺序。

    springboot项目启动时主要流程是这样的：

    在SpringApplication类的callRunners方法中，我们能看到这两个接口的具体调用：

    最后还有一个问题：这两个接口有什么区别？

    一直想整理出一份完美的面试宝典，但是时间上一直腾不开，这套一千多道面试题宝典，结合今年金三银四各种大厂面试题，以及 GitHub 上 star 数超 30K+ 的文档整理出来的，我上传以后，毫无意外的短短半个小时点赞量就达到了 13k，说实话还是有点不可思议的。

    一千道互联网 Java 工程师面试题

    内容涵盖：Java、MyBatis、ZooKeeper、Dubbo、Elasticsearch、Memcached、Redis、MySQL、Spring、SpringBoot、SpringCloud、RabbitMQ、Kafka、Linux等技术栈（485页）

    初级—中级—高级三个级别的大厂面试真题

    阿里云——Java 实习生/初级

    List 和 Set 的区别 HashSet 是如何保证不重复的

    HashMap 是线程安全的吗，为什么不是线程安全的（最好画图说明多线程环境下不安全）?

    HashMap 的扩容过程

    HashMap 1.7 与 1.8 的 区别，说明 1.8 做了哪些优化，如何优化的？

    对象的四种引用

    Java 获取反射的三种方法

    Java 反射机制

    Arrays.sort 和 Collections.sort 实现原理 和区别

    Cloneable 接口实现原理

    异常分类以及处理机制

    wait 和 sleep 的区别

    数组在内存中如何分配

    答案展示：

    美团——Java 中级

    BeanFactory 和 ApplicationContext 有什么区别

    Spring Bean 的生命周期

    Spring IOC 如何实现

    说说 Spring AOP

    Spring AOP 实现原理

    动态代理（cglib 与 JDK）

    Spring 事务实现方式

    Spring 事务底层原理

    如何自定义注解实现功能

    Spring MVC 运行流程

    Spring MVC 启动流程

    Spring 的单例实现原理

    Spring 框架中用到了哪些设计模式

    为什么选择 Netty

    说说业务中，Netty 的使用场景

    原生的 NIO 在 JDK 1.7 版本存在 epoll bug

    什么是 TCP 粘包/拆包

    TCP 粘包/拆包的解决办法

    Netty 线程模型

    说说 Netty 的零拷贝

    Netty 内部执行流程

    答案展示：

    蚂蚁金服——Java 高级

    题 1：

    1. jdk1.7 到 jdk1.8 Map 发生了什么变化(底层)?

    2. ConcurrentHashMap

    3. 并行跟并发有什么区别？

    4. jdk1.7 到 jdk1.8 java 虚拟机发生了什么变化?

    5. 如果叫你自己设计一个中间件,你会如何设计?

    6. 什么是中间件？

    7. ThreadLock 用过没有,说说它的作用?

    8. Hashcode（）和 equals（）和==区别?

    9. mysql 数据库中,什么情况下设置了索引但无法使用?

    10. mysql 优化会不会,mycat 分库,垂直分库,水平分库?

    11. 分布式事务解决方案?

    12. sql 语句优化会不会,说出你知道的?

    13. mysql 的存储引擎了解过没有?

    14. 红黑树原理？

    题 2：

    1. 说说三种分布式锁？

    2. redis 的实现原理？

    3. redis 数据结构，使⽤场景？

    4. redis 集群有哪⼏种？

    5. codis 原理？

    6. 是否熟悉⾦融业务？记账业务？蚂蚁⾦服对这部分有要求。

    好啦~展示完毕，大概估摸一下自己是青铜还是王者呢？

    前段时间，在和群友聊天时，把今年他们见到的一些不同类别的面试题整理了一番，于是有了以下面试题集，也一起分享给大家~

    如果你觉得这些内容对你有帮助，可以加入csdn进阶交流群，领取资料

    基础篇


    JVM 篇


    MySQL 篇



    Redis 篇




    由于篇幅限制，详解资料太全面，细节内容太多，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容!

    需要的小伙伴，可以一键三连，下方获取免费领取方式！
    在这里插入图片描述

    以上是关于Spring 中那些让你爱不释手的代码技巧的主要内容，如果未能解决你的问题，请参考以下文章

    spring中这些能升华代码的技巧，可能会让你爱不释手

    Java中那些让你爱不释手工具库，精炼代码量

    项目中用了spring这些牛逼的开发技巧，经理请我吃饭了

    MacOS上的这些隐藏小技巧，一旦掌握，爱不释手！

    9个小技巧让你的 if else看起来更优雅

    9个小技巧让你的 if else看起来更优雅