1 Spring IOC容器
(1)IOC底层原理
(2)IOC接口(BeanFactory)
(3)IOC操作Bean管理(基于XML)
(4)IOC操作Bean管理(基于注释)
1.1 IOC概念
(1)控制反转(Inversion of Control)，把对象的创建和对象之间的调用过程，交给Spring进行管理。
(2)使用IOC目的：为了降低耦合度。
(3)IOC底层原理：xml解析、工厂模式、反射。
工厂模式：降低耦合度。
反射：得到类的字节码文件。
1.2 IOC底层原理
在UserService类中调动用UserDao类中的方法。
class UserService{
execute()
{
}
}
class UserDao{
add()
{
...
}
}
1.2.1 原始方式(耦合度高)
1.2.2 工厂模式(解耦)
1.2.3 IOC过程 (最低耦合度)
1.3 IOC接口
1、IOC思想基于IOC容器完成，IOC容器底层就是对象工厂。
2、Spring提供IOC容器实现两种方式:(两个接口)
(1)BeanFactory：IOC容器基本实现，是Spring内部使用的接口，不提供开发人员进行使用。
加载配置文件时不会创建对象，在获取对象或使用对象时才会创建。
(2)ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用。
加载配置文件时，就会把在配置文件中的对象都进行创建。
3、ApplicationContext中的实现类
(1)FileSystemXmlApplicationContext
(2)ClassPathXmlApplicationContext
1.4 Bean管理
1、什么是Bean管理
Bean管理指的是两个操作：
(1)Spring创建对象
(2)Spring注入属性
2、Bean管理操作有两种方式：
(1)基于xml配置文件方式实现
(2)基于注解方式实现
2 基于xml方式
2.1 创建对象
2.1.1 new方法(原始)
HellowWorld hello = new HelloWorld();
2.1.2 xml方式(spring)
1、基于xml方式创建对象
<!--配置HellowWorld对象创建-->
<bean id="helloWorld123" class="HelloWorld"></bean>
(1)在spring配置文件中，使用bean标签，
标签里面添加对应属性，就可以实现对象创建。
(2)在bean标签中有很多属性
id属性：唯一标识。
class属性：类全路径(包名+类名)。
name属性：与id属性功能相似，已不再使用。
(3)创建对象的时候，默认也是执行无参数构造方法
2.2 set方法注入属性
2、 基于xml方式注入属性
DI:依赖注入，就是注入属性
第一种注入方式：使用set方法进行注入
步骤：创建类，定义属性和对应的set方法
步骤：在spring的配置文件中进行配置。
第二种注入方式：使用有参数构造进行注入
步骤：创建类，定义属性，创建属性对应有参数构造方法。
步骤：在spring的配置文件中进行配置。
2.2.1 set方法(原始)
public class Book {
//创建属性
private String bname;
private String bauthor;
//创建属性对应的set方法
public void setBname(String bname) {
this.bname = bname;
}
public void setBauthor(String bauthor) {
this.bauthor = bauthor;
}
public void getMessage(){
System.out.println(bname+":"+bauthor);
}
public static void main(String[] args){
// 使用时，先创建对象，再用set方法注入属性
Book book = new Book();
book.setBname("孔乙己");
book.setBauthor("鲁迅");
book.getMessage();
}
}
2.2.2 xml方式(spring)
使用property完成属性注入
name：类里面属性名称
value：向属性注入的值
<bean id="book" class="Book">
<property name="bname" value="孙子兵法" />
<property name="bauthor" value="孙子" />
</bean>
使用方式
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class zzz {
public static void main(String[] args) {
// 1 加载spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
// 2 获取配置创建的对象
Book book = (Book) context.getBean("book");
book.getMessage();
}
}
2.3 有参构造注入属性
2、 基于xml方式注入属性
DI:依赖注入，就是注入属性
第一种注入方式：使用set方法进行注入
步骤：创建类，定义属性和对应的set方法
步骤：在spring的配置文件中进行配置。
第二种注入方式：使用有参数构造进行注入
步骤：创建类，定义属性，创建属性对应有参数构造方法。
步骤：在spring的配置文件中进行配置。
2.3.1 构造方法(原始)
右键->Generate->选择生成有参构造
public class Orders {
//创建属性
private String oname;
private String address;
// 创建有参构造
public Orders(String oname, String address) {
this.oname = oname;
this.address = address;
}
public void getMessage(){
System.out.println(oname+":"+address);
}
public static void main(String[] args){
// 使用时
Orders order = new Orders("lily","NewYork");
order.getMessage();
}
}
2.3.2 xml方式(spring)
<!--有参构造注入属性-->
<bean id="orders" class="Orders">
<constructor-arg name="oname" value="lucy"/>
<constructor-arg name="address" value="china"/>
</bean>
使用方式
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class zzz {
public static void main(String[] args) {
// 1 加载spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
// 2 获取配置创建的对象
Orders order = (Orders) context.getBean("orders");
order.getMessage();
}
}
2.4 p名称空间注入
(1)使用p名称空间注入，可以简化基于xml的set方法注入
第一步 添加p名称空间在配置文件中
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
第二步 进行属性注入，在bean标签中进行操作
<bean id="book" class="Book" p:bname="天龙八部" p:bauthor="金庸"></bean>
2.5 注入null和特殊字符
一、字面量
(1)null值
<bean id="book" class="Book">
<property name="bname" value="孙子兵法" />
<property name="bauthor">
<null/>
</property>
</bean>
输出如下:孙子兵法:null
(2)属性值包含特殊符号
方式一：把<>进行转移 <>
<bean id="book" class="Book">
<property name="bname" value="孙子兵法" />
<property name="bauthor" value="<<孙子>>"/>
</bean>
方式二：把带特殊符号内容写到CDATA
<bean id="book" class="Book">
<property name="bname" value="孙子兵法" />
<property name="bauthor">
<value><![CDATA[<<老子>>]]></value>
</property>
</bean>
2.6 注入外部Bean
web层，service层，dao层。
2、注入属性-外部bean
(1)创建两个类service类和dao类
(2)在service中调用dao
(3)在spring配置文件中配置
2.6.1 原始方式
一、Dao层接口
代码文件UserDao.java
package dao;
public interface UserDao {
public void update();
}
二、Dao层接口实现
代码文件UserDaoImpl.java
package dao;
public class UserDaoImpl implements UserDao{
@Override
public void update() {
System.out.println("dao update ......");
}
}
三、service层
代码文件UserService.java
package service;
import dao.UserDao;
import dao.UserDaoImpl;
public class UserService {
public void add(){
System.out.println("service add ......");
// 在service层中调用Dao层
// 创建UserDao对象
UserDao userdao = new UserDaoImpl();
userdao.update();
}
public static void main(String[] args) {
UserService userservice = new UserService();
userservice.add();
}
}
2.6.2 xml方式
一、Dao层接口
代码文件UserDao.java
二、Dao层接口实现
代码文件UserDaoImpl.java
三、service层
代码文件UserService.java
package service;
import dao.UserDao;
public class UserService {
//创建UserDao类型属性,生成set方法
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void add(){
System.out.println("service add ......");
// 调用dao层
userDao.update();
}
}
四、beans.xml配置文件
<!-- 1 service和dao对象创建-->
<bean id="userservice123" class="service.UserService">
<!--注入userDao对象
name属性：类里面的属性名称
ref属性：创建userDao对象bean标签id值
-->
<property name="userDao" ref="userDaoImpl123"/>
</bean>
<bean id="userDaoImpl123" class="dao.UserDaoImpl"></bean>
五、测试使用
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.UserService;
public class zzz {
public static void main(String[] args) {
// 1 加载spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
// 2 获取配置创建的对象
UserService userservice = (UserService) context.getBean("userservice123");
userservice.add();
}
}
2.7 注入内部Bean
(1)一对多关系：部门和员工
一个部门有多个员工，一个员工属于一个部门
(2)在实体类间表示一对多关系,员工所属部门，使用对象类型属性表示
一、Dept.java
//部门类
public class Dept {
private String dname;
public void setDname(String dname) {
this.dname = dname;
}
public String getDname() {
return dname;
}
}
二、Emp.java
//员工类
public class Emp {
private String ename;
private String gender;
//员工属于某一个部门，使用对象类型属性表示
private Dept dept;
public void setDept(Dept dept) {
this.dept = dept;
}
public void setEname(String ename) {
this.ename = ename;
}
public void setGender(String gender) {
this.gender = gender;
}
public void getMessage(){
System.out.println(ename+":"+gender+":"+dept);
}
}
三、beans.xml配置文件
<!--内部bean-->
<bean id="emp" class="Emp">
<!--设置两个普通属性-->
<property name="ename" value="lily"/>
<property name="gender" value="女"/>
<!--设置对象类型属性-->
<property name="dept">
<bean id="dept" class="Dept">
<property name="dname" value="人力资源部"/>
</bean>
</property>
</bean>
四、测试
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class zzz {
public static void main(String[] args) {
// 1 加载spring配置文件
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
// 2 获取配置创建的对象
Emp emp = (Emp) context.getBean("emp");
emp.getMessage();
}
}
2.8 级联赋值
(1)第一种写法：
<!--级联赋值-->
<bean id="emp" class="Emp">
<!--设置两个普通属性-->
<property name="ename" value="lily"/>
<property name="gender" value="女"/>
<!--级联赋值-->
<property name="dept" ref="dept12"/>
</bean>
<bean id="dept12" class="Dept">
<property name="dname" value="人力资源部"/>
</bean>
(2)第二种方法
<!--级联赋值-->
<bean id="emp" class="Emp">
<!--设置两个普通属性-->
<property name="ename" value="lily"/>
<property name="gender" value="女"/>
<!--级联赋值-->
<property name="dept" ref="dept12"/>
<property name="dept.dname" value="技术部"/>
</bean>
<bean id="dept12" class="Dept">
<property name="dname" value="人力资源部"/>
</bean>
第二种方法需要注意：
3 Spring IoC容器
IoC(Inverse of Control)控制反转。
IoC指的是将对象的创建权交给Spring去创建。使用Spring之前，对象的创建都是由我们使用new创建，而使用Spring之后，对象的创建都交给了Spring框架。
IoC容器是Spring的核心，也可以称为Spring容器。Spring通过IoC容器来管理对象的实例化和初始化，以及对象从创建到销毁的整个生命周期。
Spring中使用的对象都由IoC容器管理，不需要我们手动使用new运算符创建对象。由 IoC容器管理的对象称为Spring Bean，Spring Bean就是Java对象，和使用new运算符创建的对象没有区别。
Spring通过读取XML或Java注解中的信息来获取哪些对象需要实例化。
Spring提供2种不同类型的IoC容器，即BeanFactory和ApplicationContext容器。
3.1 BeanFactory容器
BeanFactory是最简单的容器，由org.springframework.beans.factory.BeanFactory接口定义，采用懒加载(lazy-load)，所以容器启动比较快。
BeanFactory 提供了容器最基本的功能。
为了能够兼容 Spring集成的第三方框架(如BeanFactoryAware、InitializingBean、DisposableBean)，所以目前仍然保留了该接口。
简单来说，BeanFactory就是一个管理Bean的工厂，它主要负责初始化各种Bean，并调用它们的生命周期方法。
BeanFactory 接口有多个实现类，
最常见的是org.springframework.beans.factory.xml.XmlBeanFactory。
使用BeanFactory需要创建XmlBeanFactory类的实例，
通过XmlBeanFactory类的构造函数来传递Resource对象。如下所示。
Resource resource = new ClassPathResource("Beans.xml");
BeanFactory factory = new XmlBeanFactory(resource);
MainApp.java文件
package net.biancheng;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
public class MainApp {
public static void main(String[] args) {
Resource resource = new ClassPathResource("Beans.xml");
BeanFactory factory = new XmlBeanFactory(resource);
HelloWorld obj = (HelloWorld) factory.getBean("helloWorld123");
obj.getMessage();
}
}
在主程序当中，需要注意以下两点：
(1)第一步利用框架提供的XmlBeanFactory() API去生成工厂bean以及利用 ClassPathResource() API去加载在路径CLASSPATH下可用的bean配置文件。XmlBeanFactory() API负责创建并初始化所有的对象，即在配置文件中提到的 bean。
(2)第二步利用第一步生成的bean工厂对象的getBean()方法得到所需要的bean。 这个方法通过配置文件中的bean ID来返回一个真正的对象，该对象最后可以用于实际的对象。一旦得到这个对象，你就可以利用这个对象来调用任何方法。
后期这个XmlBeanFactory类被废除了。
3.2 ApplicationContext容器
ApplicationContext继承了BeanFactory接口，由 org.springframework.context.ApplicationContext接口定义，对象在启动容器时加载。ApplicationContext在BeanFactory的基础上增加了很多企业级功能，例如AOP、国际化、事件支持等。
ApplicationContext 接口有两个常用的实现类，具体如下。
(1)ClassPathXmlApplicationContext
该类从类路径ClassPath中寻找指定的XML配置文件，并完成ApplicationContext的实例化工作，具体如下所示。
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(String configLocation);
在上述代码中，configLocation参数用于指定Spring配置文件的名称和位置，如 Beans.xml。
(2)FileSystemXmlApplicationContext
该类从指定的文件系统路径中寻找指定的 XML 配置文件，并完成ApplicationContext的实例化工作，具体如下所示。
ApplicationContext applicationContext = new FileSystemXmlApplicationContext(String configLocation);
它与 ClassPathXmlApplicationContext 的区别是：在读取 Spring 的配置文件时，FileSystemXmlApplicationContext 不会从类路径中读取配置文件，而是通过参数指定配置文件的位置。即 FileSystemXmlApplicationContext 可以获取类路径之外的资源，如“F:/workspaces/Beans.xml”。
扫一扫
229
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
