目录
底层原理
IOC控制反转 ，把对象创建和对象之间的调用过程，交给Spring进行管理
目的：降低耦合度
底层原理：
xml解析，工厂模式，反射
降低耦合度的过程：
原始方式
工厂模式
最终效果：
进一步降低耦合度
newInstance()创建对象
IOC接口（BeanFactory）
1. IOC思想是基于IOC容器完成，IOC容器底层是对象工厂
2.Spring提供IOC容器实现的两种方式（两个接口）
（1）BeanFactory:IOC容器的基本实现，是Spring内部的使用接口，不提供开发人员使用
*加载配置文件时不会创建对象，在获取对象时才去创建对象
（2）ApplicationContext：BeanFactory的子接口，提供更多强大的功能，一般由开发人员使用
*加载配置文件时就会把在配置文件的对象进行创建
3.ApplicationContext接口的实现类
FileSystemXmlApplicationContext 绝对路径 写文件的全路径，从c盘开始
ClassPathXmlApplicationContext 相对路径
IOC操作Bean（基于xml）
1.什么是Bean管理
Bean指的是两个操作： Spring创建对象 Spring注入属性
Bean管理操作的两种方式： 基于XML配置文件方式实现，基于注解方式实现
1.基于XML创建对象
（1）在Spring 配置文件中，使用Bean标签，标签里添加对应的属性，就可以实现对象的创建
（2）在bean中有很多属性，常用的属性有
*id属性：唯一标识
*class属性：类全路径（包类路径）
（3）常见对象是，默认执行无参构造
2..基于XML注入属性
（1）DI：依赖注入，就是注入属性
第一种，使用set方法进行构造
（1）创建类，定义属性和set方法
public class User {
private String ubook;
private String uautor;
// public User() {
// }
//
// public User(String ubook, String uautor) {
// this.ubook = ubook;
// this.uautor = uautor;
// }
public String getUbook() {
return ubook;
}
public String getUautor() {
return uautor;
}
public void setUbook(String ubook) {
this.ubook = ubook;
}
public void setUautor(String uautor) {
this.uautor = uautor;
}
void add() {
System.out.println("add....");
}
void testdome() {
System.out.println(ubook + " " + uautor);
}
}
（2）在spring配置文件中配置对象创建，配置属性注入
&&&&&&& 写name 是一定要注意，之前多写了一个空格 &&&&&&&&&
<bean id="user" class="User">
<!--使用property完成属性注入-->
<property name="ubook" value="西游记"></property>
<property name="uautor" value="老罗"></property>
</bean>（3）测试类
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import javax.management.InvalidApplicationException;
public class tset {
@Test
public void tsetadd() {
//加载配置文件
ApplicationContext con = new ClassPathXmlApplicationContext("bean.xml");
//创建对象
User user = con.getBean("user", User.class);
System.out.println(user);
user.testdome();
}
}
第二种，有参构造注入
（1）创建类，用有参数构造
public class User {
private String ubook;
private String uautor;
public User() {
}
public User(String ubook, String uautor) {
this.ubook = ubook;
this.uautor = uautor;
}
void add() {
System.out.println("add....");
}
void testdome() {
System.out.println(ubook + " " + uautor);
}
}
（2）在spring配置文件中配置对象创建，配置属性注入
constructor-arg 关键字
<bean id="user" class="User">
<constructor-arg name="ubook" value="亮剑"></constructor-arg>
<constructor-arg name="uautor" value="李云龙"></constructor-arg>
</bean>（3）测试类同上
5.set注入优化 p名称空间注入
xml注入其他类型属性
1.字面量
（1）null值 值为空的情况
<property name="uautor">
<null></null>
</property>（2）属性值包含特殊符号
1.把<>进行转义 < 或 > 都可
2.把带特殊符号的内容写进CDATA
<property name="uautor">
<value><![CDATA[<<南京>>]]]></value>
</property>2.注入属性=外部bean
（1）创建两个类service和dao类
service类
package service;
import dao.UserDao;
public class UserService {
//创建UserDao类型的属性
private UserDao userDao;
public void setUseerDao(UserDao useerDao) {
this.userDao = useerDao;
}
public void add(){
System.out.println("service......");
userDao.update();
}
}
dao类
package dao;
public class UserDaol implements UserDao{
@Override
public void update() {
System.out.println("update...");
}
}
（2）在service中调用dao方法
（3）在spring配置文件中进行配置
<bean id="userService1" class="service.UserService">
<!--注入userDao对象
name 属性值 类里面的属性名称
ref 创基userDao对象bean标签的id值
-->
<property name="useerDao" ref="userDaomm"></property>
</bean>
<bean id="userDaomm" class="dao.UserDaol"></bean>测试
public class tset {
@Test
public void tsetadd() {
//加载配置文件
ApplicationContext con = new ClassPathXmlApplicationContext("bean1.xml");
//创建对象
UserService user = con.getBean("userService1", UserService.class);
System.out.println(user);
user.add();
}
}（3）注入属性-内部bean和级联赋值
一对多的关系
xml注入集合
注入数组类型
注入list类型
注入MAP类型
（1）创建相应的类，生成set方法
package Collection;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class stu {
private String[] cou;
private List<String> list;
private Map<String,String> map;
private Set<String> set;
public void setCou(String[] cou) {
this.cou = cou;
}
public void setList(List<String> list) {
this.list = list;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
public void setSet(Set<String> set) {
this.set = set;
}
public void test(){
System.out.println(Arrays.toString(cou));
System.out.println(list);
System.out.println(map);
System.out.println(set);
}
}
（2）配置xml
<bean id="stu" class="Collection.stu">
<!--数组类型-->
<property name="cou">
<array>
<value>语文</value>
<value>数学</value>
<value>英语</value>
</array>
</property>
<!--list类型-->
<property name="list">
<list>
<value>li1</value>
<value>li2</value>
<value>li3</value>
</list>
</property>
<!--map类型-->
<property name="map">
<map>
<entry key="JAVA" value="java"></entry>
<entry key="PYTHON" value="python"></entry>
</map>
</property>
<!--set类型-->
<property name="set">
<set>
<value>set4</value>
<value>set2</value>
</set>
</property>
</bean>（3）结果展示
public class tset1 {
@Test
public void test(){
ApplicationContext con= new ClassPathXmlApplicationContext("bean3.xml");
stu stu=con.getBean("stu", Collection.stu.class);
stu.test();
}
}
（4）在集合中设置对象类型的值
创建相应的类
package Collection;
public class kecheng {
private String kecheng;
public void setKecheng(String kecheng) {
this.kecheng = kecheng;
}
}
//----------stuzhong-----------
private Set<String> set;
public void setKechengList(List<kecheng> kechengList) {
this.kechengList = kechengList;
}xml配置
<bean id="stu" class="Collection.stu">
<!--对象 类型-->
<property name="kechengList">
<list>
<ref bean="kecheng1"></ref>
<ref bean="kecheng2"></ref>
</list>
</property>
</bean>
<bean id="kecheng1" class="Collection.kecheng">
<property name="kecheng" value="数据库"></property>
</bean>
<bean id="kecheng2" class="Collection.kecheng">
<property name="kecheng" value="软件工程"></property>
</bean>
（5）把集合公共部分抽取出来
1.引入命名空间util
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/beans/spring-util.xsd">添加相关类
package Collection;
import java.util.List;
public class book {
private List<String> list;
public void setList(List<String> list) {
this.list = list;
}
public void test1(){
System.out.println(list);
}
}
xml配置文件
<util:list id="book">
<value>西游记</value>
<value>西游记1</value>
<value>西游记2</value>
</util:list>
<bean id="book" class="Collection.book">
<property name="list" ref="book"></property>
</bean>
IOC操作Bean 管理（FactoryBean）
1.String 有两种Bean，一种是普通Bean,一种是工厂bean(FactoryBean)
2.普通bean:在配置文件中定义什么类型，返回的就是什么类型
3.工厂bean：在配置文件中定义的bean类型可以与返回类型不同
（1）创建类，让这个类作为工厂bean ,实现FactoryBean
（2）实现接口中的方法，在实现方法中定义返回的bean类型
相关类
package Collection;
import org.springframework.beans.factory.FactoryBean;
public class facbean implements FactoryBean<stu> {
//定义返回类型
@Override
public stu getObject() throws Exception {
stu stu=new stu();
return stu;
}
@Override
public Class<?> getObjectType() {
return null;
}
@Override
public boolean isSingleton() {
return FactoryBean.super.isSingleton();
}
}
配置
<bean id="mybean" class="Collection.facbean">
</bean>测试
@Test
public void test3(){
ApplicationContext con= new ClassPathXmlApplicationContext("bean5.xml");
stu stu=con.getBean("mybean", stu.class);
stu.test1();
}bean作用域
1.在Spring里，设置创建的bean实例是单实例还是多实例
2.在Spring里，默认是单实例对象
3.如何设置单实例还是多实例。
1）在spring配置文件中bean中有一个属性 scope ，用于设置单实例还是多实例
2）scope属性
默认值。singleton，单实例对象
prototype，多实例对象
<bean id="mybean" class="Collection.facbean" scope="prototype"></bean>
4.singleton与 prototype区别
设置scope值为 singleton时，加载Spring配置文件时创建对象
设置scope值为 prototype时，在调用getBean方法时创建对象
bean生命周期
1.生命周期
从对象创建到对象销毁的过程
2.bean生命周期
1》通过构造器创建bean 实例（无参构造）
2》为bean 的属性设置值和对其他bean 用用（调用set方法）
3.0 把bean的实例传递给bean的后置处理器（实现BeanPostProcessor接口） 执行 postProcessBeforInitlization方法
3》调用bean 的初始化方法（）需要进行配置初始化方法
3.1 把bean的实例传递给bean的后置处理器 执行 postProcessAfterInitlization方法
4》bean可以使用了
5》当容器关闭时，调用bean的销毁方法（需要进行配置销毁方法）
xml自动装配
1.自动装配 根据指定装配规则（属性名称或属性类型），Spring自动完成属性的注入
<!--实现自动装配
采用标签autowire
autowire有两个个常用值
byName根据属性名称注入，注入值bean的id和类属性，名称一样
byType 根据属性类型注入
-->
<bean id="userService1" class="service.UserService" autowire="byType"></bean>
<bean id="userDaomm" class="dao.UserDaol"></bean>
xml引入外部文件
以数据库配置文件为例
1.直接配置
引入外部文件配置
创建外部文件，properties格式文件，
把外部文件引入Spring配置文件
1.引入context命名空间
2.以引入外部文件
3.配置连接池
IOC操作Bean（基于注解）
什么是注解
1.注解是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值）
2.使用注解，注解作用在类上，方法上，属性上
3.使用注解目的，简化xml配置
Spring针对Bean 管理中创建对象提供的注解
1.@Component
2.@Service
3.@Controller
4.@Repository
基于注解方式实现对象创建
1.引入依赖
2.引入context名称空间，开启组件扫描
<!--开启组件扫描
1.如果扫描多个包，使用，隔开
2.扫描包上层目录
-->
<context:component-scan base-package="service"></context:component-scan>3.配置相关类
package service;
import dao.UserDao;
import org.springframework.stereotype.Component;
//在注解里面的value值可以不写，
//默认值是类名称，首字母小写
@Component
public class UserService {
public void add(){
System.out.println("service......");
}
}
4.测试
@Test
public void test4(){
ApplicationContext con= new ClassPathXmlApplicationContext("bean6.xml");
UserService userService=con.getBean("userService", UserService.class);
userService.add();
}5.开启组件扫描细节
基于注解方式实现属性注入
1.@AutoWired:根据属性类型进行自动装配
1》把service和dao对象创建，在service和dao类添加创建对象注解
2》在service注入dao对象，在service类添加dao类型属性。在 属性上使用注解
//dao接口
package springLianXi.dao;
public interface UserDao {
public void add();
}
//dao实现类
package springLianXi.dao;
import org.springframework.stereotype.Repository;
//定义dao类型属性
//不需要添加set方法
//添加注入属性注解
@Repository
public class UserDaodo implements UserDao{
@Override
public void add() {
System.out.println("add......");
}
}
//service实现类
@Service
public class UserService {
@Autowired
private UserDao userDao;
public void add(){
userDao.add();
System.out.println("service.....");
}
}
2.@Qualifier：根据属性名称进行注入
@Qualifier注解的使用要与@AutoWired一起使用
package springLianXi.dao;
import org.springframework.stereotype.Repository;
//定义dao类型属性
//不需要添加set方法
//添加注入属性注解
@Repository(value = "userDaodo1")
public class UserDaodo implements UserDao{
@Override
public void add() {
System.out.println("add......");
}
}
//+++++++++++++++++++++
@Service
public class UserService {
@Autowired
@Qualifier(value = "userDaodo1")
private UserDao userDao;
public void add(){
userDao.add();
System.out.println("service.....");
}
}3.@Resource：可以根据类型注入，也可以根据名称 注入
@Service
public class UserService {
// @Autowired
// @Qualifier(value = "userDaodo1")
// @Resource//根据类型注入
@Resource(name = "userDaodo1")
private UserDao userDao;
public void add(){
userDao.add();
System.out.println("service.....");
}
}4.@Value:注入普通类型
@Value(value = "张三")
private String name;纯注解开发
创建配置类，
@Configuration//作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"springLianXi"})
public class SpringConfig {
}编写测试类
@Test
public void test2(){
// ApplicationContext con=new AnnotationConfigApplicationContext("springLianXi"); //这个也可以
ApplicationContext con=new AnnotationConfigApplicationContext(SpringConfig.class);
UserService userService=con.getBean("userService", UserService.class);
userService.add();
}
}
1475
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
