springbootEE读书笔记（1） Spring和SpringBoot基础之 Spring基础

蔚落 2023-07-10 05:03 5阅读 0赞

Spring基础

1、spring框架是一个轻量级的企业级开发的一站式解决方案

spring框架主要提供了Ioc容器、AOP、数据访问、Web开发、消息、测试等

POJO -- Pliant Old Java Object,**无任何限制的普通对象**

每一个被Spring管理的Java对象成为Bean

***IoC***: spring提供了一个IoC容器用来初始化对象，解决对象间的依赖管理和对象的使用

**2、maven项目管理工具**

groupId 组织的唯一标识

artifactId 项目的唯一标识

maven仓库： http://mvnrepository.com

3、spring框架本身的四大原则  
 1）使用POJO进行轻量级和最小侵入式开发

2）通过***依赖注入DI***和基于接口编程实现松耦合

3）通过AOP和默认习惯进行***声明式编程***

4）使用AOP和模板减少模式化代码

4、依赖注入

**控制翻转 IoC**： Inversion of Control，***容器负责创建***对象和维护对象间的依赖关系，而不是通过对象本身负责自己的创建和解决自己的依赖。

**依赖注入 DI**： dependency injection，注入的目的主要是为了***解耦***，体现了一种“***组合***”的理念；继承父类，会使耦合性增大

spring中两者等同概念，控制翻转是通过依赖注入实现的

Spring IoC容器（ApplicationContext）负责创建Bean，并通过容器将功能类Bean注入到你需要的Bean中。  
Spring提供使用Xml、注解、Java配置、groovy配置实现Bean的创建和注入

配置**元数据**： Xml、注解、Java配置、groovy配置，不具备任何执行能力，只能通过外界代码来对这些元数据解析后进行一些有意义操作；Spring容器解析这些配置元数据进行Bean初始化、配置和管理依赖、

元数据：解释数据的数据，就是所谓的配置

@Configuration 声明当前类是一个配置类

@ComponentScan自动扫描包下所有使用@Service、@Component、@Repository、@Controller的类并注册为Bean

@PropertySource("classpath：com/el/test.properties") 指定项目中的配置文件位置

5、AOP

解耦，让一组类共享相同的行为。

在oop中只能通过继承类和实现接口，来时代码的耦合度增强，且类继承只能为单继承，阻碍更多行为添加到一组类，AOP弥补oop的不足

Spring支持AspectJ的注解式切面编程

1）使用@Aspect声明一个切面

2）使用@After、@Before、@Around定义建言（advice），可直接将拦截规则（切点）作为参数；为了是切点服用，使用@PointCut定义拦截规则，然后在@After、@Before、@Around的参数中调用

3）其中符合条件的每一个被拦截处为连接点（JointPoint）

使用@EnableAspectJAutoProxy

6、Scope

Scope描述的是Spring容器如何新建Bean的实例

Singleton：  一个Spring容器中只有一个Bean的实例，此为Spring的默认配置，取容器共享一个实例

Prototype:   每次调用新建一个Bean的实例

@Scope("singleton") service未加注解就是默认Singleton

7、SpringEL

1) 注入普通字符 @Value("字符串")

2）注入操作系统属性  @Value("\#\{systemProperties\['os.name'\]\}")

3）注入表达式运算结果 @Value("\#\{ T(java.lang.math) \* random() \* 100.0 \}")

4）注入其他Bean的属性  @Value("\#\{demoService.another\}")

5）注入文件内容  @Value("classpath: com/el/test.txt")

6）注入网址内容  @Value("http://www.baidu.com")

7）注入属性文件  @Value("***$\{*** book.name\}")  或者通过注入Environment，通过environment.getProperty

8、Bean的初始化和销毁

1）java配置方式： 使用@Bean的initMethod和destoryMethod

2）注解方式： @PostConstruct 和 @PreDestroy

@PostConstruct   构造函数执行完之后执行

@PreDestory   在Bean销毁之前执行

@Bean(initMethod="init", destoryMethod="destroy")

initMethod和destroyMethod 指定类的init和destory方法在构造之后，Bean销毁之前执行

9、profile

//    servlet 3.0 及以上
    public class WebInit implements WebApplicationInitializer{
       
      @Override
      public void onStartup(ServletContext container) throw ServletException{
         container.setInitialParameter("spring.profiles.default", "dev");
      }
    }

\--------

profile配置

@Configuration
    public class ProfileConfig {
     
     @Bean
     @Profile("dev")    
     public DemoBean devDemoBean() {
       return new DemoBean("dev");
     }
    
     @Bean
     @Profile("pro")    
     public DemoBean proDemoBean() {
       return new DemoBean("pro");
     }
    }

public static void main(String[] args) {
       AnnotationConfigApplicationContext context = 
                   new AnnotationConfigApplicationContext();
    
       context.getEnvironment().setActiveProfiles("prod");
       context.getregister(ProfileConfig.class);
       context.refresh();
    
       DemoBean demo = context.getBean(DemoBean.class);
       System.out.println(demo.getContent);
    
       context.close();
    }

a) 需要先将活动的Profile设置为prod

b) 后置注册Bean配置类，不然会报Bean未定义的错误

c) 刷新容器

10、事件（Application Event）

Spring的事件需要流程：

1）自定义事件，集成ApplicationEvent

2）定义事件监听器，实现ApplicationListener，使用onApplicationEvent方法对消息进行接收处理

3）使用容器发布事件

11、Spring Aware

Spring的依赖注入的最大亮点就是Bean对Spring容器的存在是么有意识的。

但是实际项目中，需要用到Spring容器的存在，才能调用Spring所提供的的资源，这就是SpringAware

Aware接口

BeanNameAware 获取容器中Bean的名称

BeanFactoryAware 获取当前bean factory,这样可以调用容器的服务

ApplicationContextAware 当前的application  context,调用容器的服务

MessageSourceAware  获得message source,这样可以获得文本信息

ApplicationEvenPublisherAware 应用事件发布器，可以发布事件

ResourceLoaderAware  获得资源加载器，可以获得外部资源文件

SpringAware目的是为了让Bean获得Spring容器的服务

//   在com.lsf.service.aware包下新建一个test.txt
    
    package com.lsf.service.aware;
    
    import org.apache.commons.io.IOUtils;
    import org.springframework.beans.factory.BeanNameAware;
    import org.springframework.context.ResourceLoaderAware;
    import org.springframework.core.io.Resource;
    import org.springframework.core.io.ResourceLoader;
    import org.springframework.stereotype.Service;
    import sun.nio.ch.IOUtil;
    
    import java.io.IOException;
    
    /**
     * 接口获得Bean名称和资源加载的服务
     */
    @Service
    public class AwareService implements BeanNameAware, ResourceLoaderAware {
    
        private String beanName;
        private ResourceLoader resourceLoader;
    
        @Override
        public void setBeanName(String name) {
            this.beanName = name;
        }
    
        @Override
        public void setResourceLoader(ResourceLoader resourceLoader) {
            this.resourceLoader = resourceLoader;
        }
    
        public void outputResult(){
            System.out.println("Bean的名称为：" + beanName);
            Resource resource = resourceLoader.getResource("classpath: ./test.txt");
            try {
                System.out.println("ResourceLoader 加载的内容为：" + IOUtils.toString(resource.getInputStream()));
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

@Configuration
    @ComponentScan("com.lsf.service.article")
    public class AwareConfig {
    }

class Main {
        public static void main(String[] args) {
            AnnotationConfigApplicationContext context =
                    new AnnotationConfigApplicationContext(AwareConfig.class);
    
            AwareService awareService = context.getBean(AwareService.class);
            awareService.outputResult();
    
            context.close();
        }
    }

12、多线程

package com.lsf.taskexecutor;
    
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.scheduling.annotation.AsyncConfigurer;
    import org.springframework.scheduling.annotation.EnableAsync;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    
    import java.util.concurrent.Executor;
    
    @Configuration
    @ComponentScan("com.lsf.taskexecutor")
    @EnableAsync
    public class TaskExecutorConfig implements AsyncConfigurer {
    
        @Override
        public Executor getAsyncExecutor() {
            ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
            taskExecutor.setCorePoolSize(5);
            taskExecutor.setMaxPoolSize(10);
            taskExecutor.setQueueCapacity(25);
            taskExecutor.initialize();
            return taskExecutor;
        }
    }

@Service
    public class AsyncTaskService {
    
        @Async
        public void executeAsyncTask(Integer i) {
            System.out.println("执行异步任务 ： " + i);
        }
    
        @Async
        public void executeAsyncTaskPlus(Integer i) {
            System.out.println("执行异步任务+1 ： " + (i + 1));
        }
    }

class Main {
        public static void main(String[] args) {
            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TaskExecutorConfig.class);
    
            AsyncTaskService asyncTaskService = context.getBean(AsyncTaskService.class);
    
            for (int i = 0; i < 10; i++) {
                asyncTaskService.executeAsyncTask(i);
                asyncTaskService.executeAsyncTaskPlus(i);
            }
            context.close();
        }
    }

结果为异步而不是顺序的

> 执行异步任务： 3
> 
> 执行异步任务+1： 4
> 
> 执行异步任务：4
> 
> 执行异步任务+1： 5

13、计划任务

Spring3.1开始，计划任务变得异常简单。

首先通过在配置类注解@EnableScheduling 开启对计划任务的支持，然后在要执行计划任务的方法上注解@Scheduled，声明计划任务

包含cron、fixDelay、fixRate

@Service
    public class ScheduledTaskService {
    
        private static final SimpleDateFormat dateFormate = new SimpleDateFormat("HH:mm:ss");
    
        @Scheduled(fixedRate = 5000)
        public void reportCurrentTime() {
            System.out.println("每隔五秒执行一次：" + dateFormate.format(new Date()));
        }
    
        @Scheduled(cron = "0 28 11 ? * *")
        public void fixTimeExecution() {
            System.out.println("在指定时间：" + dateFormate.format(new Date()) + "执行");
        }
    }

@Configuration
    @ComponentScan("com.lsf.taskScheduler")
    @EnableScheduling
    public class TaskSchedulerConfig {
    }

class Main{
    
        public static void main(String[] args) {
            AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TaskSchedulerConfig.class);
        }
    }

此处通过config进行了过度，添加了包扫描，正常Springboot可以直接在入口类添加