Spring基本配置

Bertha 。 2022-05-16 01:53 214阅读 0赞

### spring 框架本身的四大原则： ###

1.  使用pojo进行轻量级和最小侵入式开发；
2.  通过依赖注入和基于接口编程实现松耦合；
3.  通过AOP和默认习惯进行声明式编程；
4.  通过AOP和模板（template）减少模式化代码。

**依赖注入:**  
控制反转（Inversion of control IOC ）和依赖注入（dependency injection DI）在spring环境下是等同的概念，控制反转是通过依赖注入实现的。所谓的依赖注入是指容器创建对象和维护对象之间的依赖关系。

依赖注入的目的是为了解耦。

**声明Bean的注解：**

1.  @Component组件，没有明确的角色；
2.  @Service在业务逻辑层（service层）使用；
3.  @Repository在数据访问层（dao层）使用；
4.  @Controller在展示层（MVC-Spring mvc） 使用。

**注入Bean的注解，一般情况下通用。**

1.  @Autowired: Spring 提供的注解；
2.  @Inject:JSR-330提供的注解；
3.  @Resource：JSR-250提供的注解。

@Configuration
    @ComponentScan("com.fish.ch1.service")
    public class DiConfig {
    
    }

1.  @Configuration声明当前类是一个配置类
2.  @ComponentScan，自动扫描包名下所有的使用@Service,@Component,@Repository和@Controller的类；

**Java配置：**是Spring4.x推荐的配置方式，可以完全替代xml的配置；也是Spring Boot 推荐的配置方式；通过@Configuration @Bean 来实现的

**AOP:**面向切面编程；AOP存在的目的是为了解耦，AOP可以让一组类共享相同的行为，在OOP中，只能通过继承类和实现接口，来使代码的耦合度增强，切继承只能为单继承。AOP弥补了OOP的缺陷。

**Spring 支持AspectJ的注解释切面编程**

1.  使用@Aspect声明式一个切面；
2.  使用@After、@Before、@Around定义建言（advice），可以直接将拦截规则（切点）定义为参数。
3.  @After、@Before、@Around参数的拦截规则为切点（PointCut）,为了使切点服用。可使用@PointCut专门定义拦截规则，然后在@After、@Before、@Around的参数中调用。
4.  其中符合条件的每一个被拦截处为拦截点（JoinPoint）

**注解配置类：**

import java.lang.reflect.Method;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.After;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.springframework.stereotype.Component;
    
    @Aspect
    @Component
    public class LogAspect {
    	
    	@Pointcut("@annotation(com.fish.ch3.aop.Action)")
    	public void annotationPointCut() {};
    	
    	@After("annotationPointCut()")
    	public void after(JoinPoint joinPoint) {
    		MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    		Method method = signature.getMethod();
    		Action action = method.getAnnotation(Action.class);
    		
    		System.out.println("注解式拦截： " + action);
    //		System.out.println("注解式拦截： " + action.name());//空指针
    	}
    	
    	@Before("execution(* com.fish.ch3.aop.DemoMethodService.*(..))")
    	public void before(JoinPoint joinPoint) {
    		MethodSignature signature = (MethodSignature) joinPoint.getSignature();
    		Method method = signature.getMethod();
    		System.out.println("方法规则拦截： " + method.getName());
    	}
    }

@Configuration
    @EnableAspectJAutoProxy
    @ComponentScan("com.fish.ch3.aop")
    public class AopConfig {
    
    }

@EnableAspectJAutoProxy：注解开启对aspectj代理的开启；

### Spring的常用配置： ###

**Bean的scope:**

1.  scope描述了spring bean是如何创建的，通过@scope实现，其方式有：
2.  single:一个容器只有一个bean,此为spring 的默认配置，全容器共享一个bean;
3.  prototype:每次调用产生一个bean;
4.  request:web形式，每次http request产生一个新实例；
5.  session:web形式，每次http session?请求产生一个新实例。
6.  globalsession:
7.  stepscope:

**Spring el的调用：**

import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Service;
    @Service
    public class DemoService {
    	
    	@Value("其他属性")
    	private String another;
    	
    	public String getAnother() {
    		return another;
    	}
    
    	public void setAnother(String another) {
    		this.another = another;
    	}
    
    }

import java.io.IOException;
    
    import org.apache.commons.io.IOUtils;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
    import org.springframework.core.env.Environment;
    import org.springframework.core.io.Resource;
    
    @Configuration
    @ComponentScan("com.fish.ch2.el")
    @PropertySource("classpath:test1.properties")
    public class Elconfig {
    	@Value("I love you")
    	private String nomal;
    	@Value("#{systemProperties['os.name']}")
    	private String osName;
    	@Value("#{T(java.lang.Math).random() * 100.0}")
    	private double randomNumber;
    	@Value("#{demoService.another}")
    	private String fromAnother;
    	@Value("classpath:text.txt")
    	private Resource testFile;
    	@Value("http://www.baidu.com")
    	private Resource testUrl;
    	@Value("${book.name}")
    	private String bookName;
    	@Autowired
    	private Environment environment;
    	@Bean
    	public static PropertySourcesPlaceholderConfigurer placeholderConfigurer() {
    		return new PropertySourcesPlaceholderConfigurer();
    	}
    	public void outputResource() {
    		try {
    			System.out.println(nomal);
    			System.out.println(osName);
    			System.out.println(randomNumber);
    			System.out.println(fromAnother);
    			System.out.println(IOUtils.toString(testFile.getInputStream()));
    			System.out.println(IOUtils.toString(testUrl.getInputStream()));
    			System.out.println(bookName);
    			System.out.println(environment.getProperty("book.author"));
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    
    	}
    
    }

**bean的初始化和销毁：**

1.  java配置：使用@Bean的initMethod和destroyMethod
2.  注解方式：利用JSR-250的PostConstruct和PreDestorty

//@bean形成的bean
    public class BeanWayService {
    	public void init() {
    		System.out.println("@Bean-init-method");
    	}
    	
    	public BeanWayService() {
    		super();
    		System.out.println("初始化构造函数-BeanWayService");
    	}
    	
    	public void destory() {
    		System.out.println("@Bean-destory-method");
    	}
    	
    }

import javax.annotation.PostConstruct;
    import javax.annotation.PreDestroy;
    
    public class JSR250WaySerivce {
    
    	@PostConstruct
    	public void init() {
    		System.out.println("jsr250-init-method");
    	}
    
    	public JSR250WaySerivce() {
    		System.out.println("初始化构造函数-JSR250WaySerivce");
    	}
    
    	@PreDestroy
    	public void destory() {
    		System.out.println("jsr250-destory-method");
    	}
    }

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    @ComponentScan("com.fish.ch2.prepost")
    public class PrePostConfig {
    
    	@Bean
    	JSR250WaySerivce jsr250WaySerivce() {
    		return new JSR250WaySerivce();
    	}
    
    	@Bean(initMethod = "init", destroyMethod = "destory")
    	BeanWayService beanWayService() {
    		return new BeanWayService();
    	}
    }

**Profile:**

1.  通过设定Environment的ActiveProfiles来设定当前的context需要使用的配置环境。在开发中使用@Profile注解类或者方法，达到在不同情况下选择实例化不同的Bean
2.  通过设定jvm的spring.profile.active参数来设定配置环境
3.  Web项目设置在Servlet的context parameter中

public class DemoBean {
    	private String content;
    
    	public DemoBean(String content) {
    		super();
    		this.content = content;
    	}
    
    	public String getContent() {
    		return content;
    	}
    
    	public void setContent(String content) {
    		this.content = content;
    	}
    
    }

import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Profile;
    
    public class ProfileConfig {
    
    	
    	@Bean
    	@Profile("dev")
    	public DemoBean devDemoBean() {
    		return new DemoBean("from development profile!");
    	}
    	
    	
    	@Bean
    	@Profile("prod")
    	public DemoBean prodDemoBean() {
    		return new DemoBean("from production profile!");
    	}
    }

public class MainTestProfile {
    	public static void main(String[] args) {
    		AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
    		ac.getEnvironment().setActiveProfiles("dev");
    		ac.register(ProfileConfig.class);
    		ac.refresh();
    		DemoBean demoBean = ac.getBean(DemoBean.class);
    		System.out.println(demoBean.getContent());
    		ac.close();
    	}
    }

**事件：**

Spring 的事件（Application Event）为Bean和Bean之间的消息通信提供了支持，当Bean处理完一个任务之后，希望另外一个Bean监听当前的Bean所发送的事件。

处理流程:

1.  自定义事件，集成applicationEvent.
2.  定义事件监听器，实现ApplicationListener.
3.  使用容器发布事件。

/**
     * 
     * 自定义事件
     * 
     * @author Administrator
     *
     */
    public class DemoEvent extends ApplicationEvent {
    
    	/**
    	 * 
    	 */
    	private static final long serialVersionUID = 9171211654655397150L;
    
    	private String msg;
    
    	public DemoEvent(Object source, String msg) {
    		super(source);
    		this.msg = msg;
    	}
    
    	public String getMsg() {
    		return msg;
    	}
    
    	public void setMsg(String msg) {
    		this.msg = msg;
    	}
    
    }

import org.springframework.context.ApplicationListener;
    import org.springframework.stereotype.Component;
    
    //事件监听器
    @Component
    public class DemoListener implements ApplicationListener<DemoEvent> {
    
    	@Override
    	public void onApplicationEvent(DemoEvent event) {
    		String msg = event.getMsg();
    
    		System.out.println("demoListener接收到的消息是：" + msg);
    	}
    
    }

@Component
    public class DemoPublisher {
    
    	@Autowired
    	ApplicationContext applicationContext;
    
    	public void publish(String msg) {
    		applicationContext.publishEvent(new DemoEvent(this, msg));
    	}
    }

@Configuration
    @ComponentScan("com.fish.ch2.event")
    public class EventConfig {
    	
    }