spring4.x快速入门

本篇文章主要记录个人学习内容，主要基于spring4.x纯注解方式。

1.创建一个maven项目，pom.xml以下修正。

把编译环境改成1.8

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
  </properties>

	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context</artifactId>
		<version>5.0.7.RELEASE</version>
	</dependency>

2.Bean装配，创建Mybean.class文件，MyConfig.class配置类。

 

（1）Bean装配，方式一

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;


@Configuration //设置配置文件类
public class MyConfig {
	
	@Bean(name="myBean")
	public MyBean createMyBean() {
		return new MyBean();
	}

}

public class MyBean {


}

public class App {
    public static void main( String[] args ){
    	AnnotationConfigApplicationContext context =new AnnotationConfigApplicationContext(MyConfig.class);
    	// 用类型获取Bean
    	System.out.println(context.getBean(MyBean.class));
    	/**
    	 * 1.默认获取Bean是按照方法的名字获取bean
    	 * 2.@Bean(name="myBean") 指定名字来获取bean
    	 */
//    	 System.out.println(context.getBean("createMyBean"));
    	 System.out.println(context.getBean("myBean"));
    	context.close();
    }
}

@Configuration：设置为配置类。

@Bean：设置bean。

默认获取Bean是按照方法的名字，装配bean。

@Bean(name="myBean") ：通过获取设置的name，装配bean。

@Scope说明

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;


@Configuration //设置配置文件类
public class MyConfig {
	
	@Bean(name="myBean")
	// 非单例模式
	@Scope("prototype")
	public MyBean createMyBean() {
		return new MyBean();
	}

}

默认是单例模式，@Scope("prototype")是非单例模式

 

 

(2)方式二

使用FactoryBean来装配bean，FactoryBean 是个特殊的Bean，专门是获取其他的Bean。

据名字获取Bean的时候，前面加&符号。可以获取Factroy 本身的bean。

import org.springframework.beans.factory.FactoryBean;

public class RunnableFactroy implements FactoryBean<Dog>{

	@Override
	public Dog getObject() throws Exception {
		
		return new Dog();
	}

	@Override
	public Class<?> getObjectType() {
		return Dog.class;
	}
	
	/**
	 * 默认是单例。
	 */
	public  boolean isSingleton() {
		return false;
	}

}

 

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;


@Configuration //设置配置文件类
public class MyConfig {
	
	@Bean(name="myBean")
	// 非单例模式
	@Scope("prototype")
	public MyBean createMyBean() {
		return new MyBean();
	}
	
	/**
	 * FactoryBean 是个特殊的Bean，专门是获取其他的对象。  
	 * 根据名字获取Bean的时候，前面加&符号。可以获取Factroy 本身的bean。
	 * @return
	 */
	@Bean
	public RunnableFactroy createRunnableFactroy() {
		return new RunnableFactroy();
	}

}

public class App {
    public static void main( String[] args ){
    	AnnotationConfigApplicationContext context =new AnnotationConfigApplicationContext(MyConfig.class);
    	// 用类型获取Bean
    	System.out.println(context.getBean(MyBean.class));
    	/**
    	 * 1.默认获取Bean是按照方法的名字获取bean
    	 * 2.@Bean(name="myBean") 指定名字来获取bean
    	 */
//    	 System.out.println(context.getBean("createMyBean"));
    	 System.out.println(context.getBean("myBean"));
    	 
    	 System.out.println(context.getBean(Dog.class));
    	 System.out.println(context.getBean("createRunnableFactroy"));
    	 //根据名字获取Bean的时候，前面加&符号。可以获取Factroy 本身的bean。
    	 System.out.println(context.getBean("&createRunnableFactroy"));
    	 
    	context.close();
    }
}

运行后的结果：

 

(3)方式三

 

通过传参的方式，注入Bean。

public class JeepFactory {
	
	public Jeep create() {
		return new Jeep();
	}

}

public class Jeep {

}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;


@Configuration //设置配置文件类
public class MyConfig {
	
	@Bean(name="myBean")
	// 非单例模式
	@Scope("prototype")
	public MyBean createMyBean() {
		return new MyBean();
	}
	
	/**
	 * FactoryBean 是个特殊的Bean，专门是获取其他的对象。  
	 * 根据名字获取Bean的时候，前面加&符号。可以获取Factroy 本身的bean。
	 * @return
	 */
	@Bean
	public RunnableFactroy createRunnableFactroy() {
		return new RunnableFactroy();
	}
	
	/**
	 * 先把JeepFactory注入到spring中。
	 * @return
	 */
	@Bean
	public JeepFactory createJeepFactroy() {
		return new JeepFactory();
	}
	/**
	 * 然后在注入createJeepFactory，同时JeepFactory传递过去。
	 * @param factory
	 * @return
	 */
	@Bean
	public Jeep createJeepFactory(JeepFactory factory) {
		return factory.create();
	}

}

public class App {
    public static void main( String[] args ){
    	AnnotationConfigApplicationContext context =new AnnotationConfigApplicationContext(MyConfig.class);
    	// 用类型获取Bean
    	System.out.println(context.getBean(MyBean.class));
    	/**
    	 * 1.默认获取Bean是按照方法的名字获取bean
    	 * 2.@Bean(name="myBean") 指定名字来获取bean
    	 */
//    	 System.out.println(context.getBean("createMyBean"));
    	 System.out.println(context.getBean("myBean"));
    	 
    	 System.out.println(context.getBean(Dog.class));
    	 System.out.println(context.getBean("createRunnableFactroy"));
    	 //根据名字获取Bean的时候，前面加&符号。可以获取Factroy 本身的bean。
    	 System.out.println(context.getBean("&createRunnableFactroy"));
    	 
    	 System.out.println(context.getBean(Jeep.class));
    	 
    	context.close();
    }
}

 

运行结果：

 

3.Bean初始化

 

下面介绍bean的初始化的三种方式。

public class App {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        System.out.println(context.getBean(Car.class));
        System.out.println(context.getBean(Dog.class));
        System.out.println(context.getBean(Animal.class));
        context.close();
    }
}

 

@Configuration
public class MyConfig {


    /**
     * 方式一
     * @return
     */
    @Bean
    public Car createCar() {
        return new Car();
    }

    /**
     * 方式二
     * @return
     */
    @Bean(initMethod="init", destroyMethod="destroy")
    public Dog createDog() {
        return new Dog();
    }

    /**
     * 方式三
     * @return
     */
    @Bean
    public Animal  createAnimal() {
        return new Animal();
    }
}

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class Car implements InitializingBean, DisposableBean{

    /**
     * InitializingBean是spring的一个接口，Bean装配之后初始化之后执行。和init方法类似。
     *
     */
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("==========InitializingBean->afterPropertiesSet========");

    }

    /**|
     * DisposableBean是spring的一个接口，销毁的时候，被执行。
     */
    @Override
    public void destroy() throws Exception {
        System.out.println("=============DisposableBean->destroy==============");
    }

}

 

public class Dog {


    public void init() {
        System.out.println("======Dog->init======");
    }

    public void destroy() {
        System.out.println("=======Dog->destroy=======");
    }
}

/**
 * 基于JSR-250注解的方式来创建销毁。
 */
public class Animal {

    @PostConstruct
    public void initial() {
        System.out.println("==========Animal->initial=========");
    }

    @PreDestroy
    public void close() {
        System.out.println("==========Animal->close=========");
    }
}

运行结果：

 

 

4.依赖注入

 

@Autowired：spring的注解。

@Resource：JSR-250注解

@Inject：JSR-330注解

 

 

AnnotationConfigApplicationContext ：

 

(1)每次注入的时候，需要把注入类class加进去。

 

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class,User.class,UserService.class,UserDao.class);

 

(2)通过扫描的方式也可以。

 

①可以通过AnnotationConfigApplicationContext去直接扫描。

 

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("com.cn.spring");

 

②通过@ComponentScan("xxx.xxx.xxx")注解的方式去扫描。

@ComponentScan("com.cn.spring")
@Configuration
public class AnnotationScan {

}

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AnnotationScan.class);