Spring框架

基本概念

IoC（Inversion of Control)控制反转

定义：使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转

IoC容器

定义：spring中使用IoC容器实现IoC
IoC容器负责对象的创建、初始化等一系列工作。

Bean

被创建或被管理的对象在IoC容器中统称为Bean

DI(Dependency Injection)依赖注入

在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入

代码样例

业务层代码

public interface BookService
	public void save();
}
1
2
3

public class BookServiceImpl implements BookService {
    private BookDao bookDao = new BookDaoImpl();

    public void save() {
        System.out.println("book service save...");
        bookDao.save();
    }
}
1
2
3
4
5
6
7
8

数据层实现

public interface BookDao {
    void save();
}
1
2
3

public class BookDaoImpl implements BookDao{
	public void save(){
		System.out.println("book dao save ...")
	}
}
1
2
3
4
5

Application

public class Application {
    public static void main(String[] args) {
        BookService bookService = new BookServiceImpl();
        bookService.save();
    }
}
1
2
3
4
5
6

pom.xml

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>5.2.10.RELEASE</version>
</dependency>
1
2
3
4
5

applicationContext.xml

<?xml version="1.0"encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
						https://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>
1
2
3
4
5
6
7

IoC使用案例

定义类和接口

public interface BookService
	public void save();
}
1
2
3

public class BookServiceImpl implements BookService {
    private BookDao bookDao = new BookDaoImpl();

    public void save() {
        System.out.println("book service save...");
        bookDao.save();
    }
}
1
2
3
4
5
6
7
8

创建配置文件，配置bean

<bean id="bookService"class="com.itheima.service.impl.BookServiceImpl"/>
1

初始化容器

public class Application {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
    }
}
1
2
3
4
5
6
7

DI使用案例

删除new
提供setter方法

public class BookServiceImpl implements BookService {
    private BookDao bookDao;

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    public void save() {
        System.out.println("book service save...");
        bookDao.save();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

配置service与dao绑定关系

<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
    <property name="bookDao" ref="bookDao"/>
</bean>
1
2
3
4

Bean属性

id：标签
name：别名
class：bean类型
scope：是否是单例
init-method：bean初始化对应的操作
destory-method：bean销毁前对应的操作
autowire：自动装配

Bean实例化

spring创造bean调用无参构造方法。

使用静态工厂实例化bean

添加工厂

public class BookDaoFactory {
    public static BookDao getBookDao() {
        return new BookDaoImpl();
    }
}
1
2
3
4
5

设置bean

<bean id="bookDao" class="com.itheima.factory.BookDaoFactory" factory-method="getBookDao"/>
1

实例工厂实例化bean

添加工厂

public class BookDaoFactory {
    public  BookDao getBookDao() {
        return new BookDaoImpl();
    }
}
1
2
3
4
5

设置bean

<bean id="bookDaoFactory" class="com.itheima.factory.BookDaoFactory"/>
<bean id="bookDao" factory-method="getBookDao" factory-bean="bookDaoFactory"/>
1
2

使用FactoryBean实例化bean

添加工厂

public class BookDaoFactoryBean implements FactoryBean<BookDao> {
    @Override
    public BookDao getObject() throws Exception {
        return new BookDaoImpl();
    }

    @Override
    public Class<?> getObjectType() {
        return BookDao.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

设置bean

<bean id="bookDao" class="com.itheima.factory.BookDaoFactoryBean"/>
1

通过接口控制bean生命周期

添加接口，代替init-method,destory-method

public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
    private BookDao bookDao;

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    public void save() {
        System.out.println("book service save...");
        bookDao.save();
    }

    @Override
    public void destroy() throws Exception {
        
    }

    @Override
    public void afterPropertiesSet() throws Exception {

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

依赖注入

setter注入

上文提到过引用类型注入
简单类型注入的bean

<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
	<property name="databaseName" value="mysql"/>
</bean>
1
2
3

构造器注入

提供构造方法
注入bean

<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
	<constructor-arg name="bookDao" ref="bookDao"/>
</bean>
1
2
3

还有按类注入，按位置注入

集合注入

<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
	<property name="array">
		<array>
			<value>100</value>
			<value>200</value>
			<value>300</value>
		</array>
	</property>
	<property name="list">
		<list>
			<value>itcast</value>
			<value>itheima</value>
			<value>boxuegu</value>
		</list>
	</property>
	<property name="set">
		<set>
			<value>itcast</value>
			<value>itheima</value>
			<value>boxuegu</value>
			<value>boxuegu</value>
		</set>
	</property>
	<property name="map">
		<map>
			<entry key=""value=""/>
			<entry key=""value=""/>
			<entry key=""value=""/>
		</map>
	</property>
</bean>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

Bean纯注解开发

定义配置类

@Configuration
@ComponentScan("com.itheima.dao")
public class SpringConfig {
}
1
2
3
4

定义类(注解，四个任选其一)

@Component("bookDao")
//@Controller:用于表现层bean定义
//@Service:用于业务层bean定义
//@Repository:用于数据层bean定义
@Scope("prototype")//单例或非单例
public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
}
1
2
3
4
5
6
7
8
9
10

@Service("bookService")
public class BookServiceImpl implements BookService {
    @Autowired
    @Qualifier("bookDao")
    private BookDao bookDao;
    
    @Value("itheima")
    private String name;

    public void save() {
        System.out.println("book service save...");
        bookDao.save();
    }

    @PreDestroy
    public void destroy() {
        System.out.println("BookService destroy");
    }

    @PostConstruct
    public void afterPropertiesSet() {
        System.out.println("BookService init");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

使用类

public class Application {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean("bookDao", BookDao.class);
        bookDao.save();
    }
}
1
2
3
4
5
6
7

加载外部properties文件

定义配置类

@Configuration
@ComponentScan("com.itheima")
@PropertySource("jdbc.properties")
public class SpringConfig {
}
1
2
3
4
5

定义类

@Service("bookService")
public class BookServiceImpl implements BookService {
    @Autowired
    @Qualifier("bookDao")
    private BookDao bookDao;

    @Value("${name}")
    private String name;

    public void save() {
        System.out.println("book service save..." + name);
        bookDao.save();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14