IOC容器
控制反转(Inversion of Control)，是面向对象编程中的一种设计原则，可以降低耦合度。包括依赖注入（Dependency Injection）、依赖查找（Dependency Lookup）。创建对象时，系统将其所依赖的对象的引用传递给自身。
原生的实现接口
java中实现一个接口功能，创建一个类来实现接口，我创建一个接口Dosomething，在创建一个Working类来实现这个接口。
public interface Dosomething { public void down();//实现某个功能 }
public class Working implements Dosomething{ @Override public void down() { //实现接口功能 } }
工厂模式
创建一个第三者将接口和实现类关联起来
public class Do_cosplay{ public void down() { System.out.println("模拟工厂模式\n"); } } public class User_cosplay{//模拟用户类 public void execute(){ Do_cosplay dosomething=Factory_cosplay.getDo_cosplay(); dosomething.down();//实现 } } public class Factory_cosplay {//模拟工厂类 public static Do_cosplay getDo_cosplay() { return new Do_cosplay(); } }
xml注解
spring提供IOC容器两种方式
- BeanFactory
- ApplicationContext
| BeanFactory | ApplicationContext |
| 加载配置文件不创建对象，获取使用创建对象 | 加载配置文件时创建配置文件 |
ClassPathXmlApplicationContext("");//对应src下的路径(相对路径) FileSystemXmlApplicationContext("");//对应绝对路径
这个路径可以在ide改，但是可能会报错（ClassNotFoundException）
推荐放在src目录下
bean无参注入
需要对象拥有无参的构造函数
基本属性
bean
id、class
class对应packge.class类、id对应唯一的对象标识（不是创建名）。
property
name、value
name对应set方法名（去掉set）、value对应set方法注入对象属性的值。
bean的创建销毁
需要配置。
init-method创建方法。
destroy-method销毁方法。
package bean_test; public class User { private String name,age,sex; public void setName(String name) { this.name = name; } public void setAge(String age) { this.age = age; } public void setSex(String sex) { this.sex = sex; } public void initmethod() { System.out.print("创建user"); } public void destroymethod() { System.out.print("销毁user"); } @Override public String toString() { return "User{" + "name='" + name + '\'' + ", age='" + age + '\'' + ", sex='" + sex + '\'' + '}'; } }
配置文件（无参构造set注入）
<bean id="user01" class="bean_test.User" init-method="initmethod" destroy-method="destroymethod"> <property name="name" value="yma16" ></property> <property name="sex" value="男"></property> <property name="age" value="18"></property> </bean>
ApplicationContext context1= new ClassPathXmlApplicationContext("bean01.xml"); User user=context1.getBean("user01",User.class); System.out.println(user);
无参注入成功！
bean的有参注入
需要有参的构造方法
constructor-arg标签
配置有参构造函数的参数属性
<bean id="" class=""> <constructor-arg name="" value=""></constructor-arg> </bean>
bean的p命名空间
在bean标签中添加
xmlns:p="http://www.springframework.org/schema/p"
属性添加
p:属性=""
在User类添加一个有参构造函数
package bean_test; public class User { private String name,age,sex; // public User() // { // System.out.println("无参构造"); // } public User(String name,String age,String sex) { this.name=name; this.age=age; this.sex=sex; System.out.println("有参构造"); } public void setName(String name) { this.name = name; } public void setAge(String age) { this.age = age; } public void setSex(String sex) { this.sex = sex; } public void initmethod() { System.out.print("创建user"); } public void destroymethod() { System.out.print("销毁user"); } @Override public String toString() { return "User{" + "name='" + name + '\'' + ", age='" + age + '\'' + ", sex='" + sex + '\'' + '}'; } }
bean设置
<bean id="user02" class="bean_test.User" init-method="initmethod" destroy-method="destroymethod"> <constructor-arg name="name" value="yma16_替身"></constructor-arg> <constructor-arg name="sex" value="男"></constructor-arg> <constructor-arg name="age" value="16"></constructor-arg> </bean>
有参注入成功！
bean注入特殊符号
字面量
private String name="yam16";//定值
null值和特殊符号< >
idea不允许直接粗暴的写<和>
分别使用< 和>转义成<和>
<property name="slog" value="<yma16>"></property>
使用CDATA
<bean id="s01" class="bean_test.Strange"> <property name="slog"> <value> <![CDATA[<yma16>]]> </value> </property> </bean>
注入外部bean
创建另一个类调用User对象
ref标签
链接bean的id
测试用例
使用创建一个Outbean类调用User类
package bean_test; public class Outbean { public User userclass;//外部的user public String Oname; public void setUserclass(User userclass) { this.userclass = userclass; } public void setOname(String oname) { Oname = oname; } @Override public String toString() { return "Outbean{" + "userclass=" + userclass + ", Oname='" + Oname + '\'' + '}'; } }
bean的配置
<bean id="Out01" class="bean_test.Outbean" init-method="initmethod" destroy-method="destroymethod"> <property name="oname" value="测试1号"></property> <property name="userclass" ref="user_ref"></property> </bean> <bean id="user_ref" class="bean_test.User" init-method="initmethod" destroy-method="destroymethod"> <constructor-arg name="name" value="yma16_ref"></constructor-arg> <constructor-arg name="sex" value="男_ref"></constructor-arg> <constructor-arg name="age" value="16_ref"></constructor-arg> </bean>
外部bean测试完成！
array、set、map、list
创建一个Array_Listcase类并且创建array、set、map、list属性。
package bean_test; import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.Set; public class Array_Listcase { public String[] array_case; public Map<String,String> map_case; public List<String> list_case; public Set<String> set_case; public void setArray_case(String[] array_case) { this.array_case = array_case; } public void setMap_case(Map<String, String> map_case) { this.map_case = map_case; } public void setList_case(List<String> list_case) { this.list_case = list_case; } public void setSet_case(Set<String> set_case) { this.set_case = set_case; } public void initmethod() { System.out.print("创建Outbean"); } public void destroymethod() { System.out.print("销毁Outbean"); } @Override public String toString() { return "Array_Listcase{" + "array_case=" + array_case + ", map_case=" + map_case + ", list_case=" + list_case + ", set_case=" + set_case + '}'; } }
bean配置
<bean id="case01" class="bean_test.Array_Listcase" init-method="initmethod" destroy-method="destroymethod"> <property name="array_case"> <array> <value>yma16</value> <value>18</value> </array> </property> <property name="map_case"> <map> <entry key="I am a keay" value="I am a value"></entry> <entry key="yma16" value="yma16 value"></entry> </map> </property> <property name="list_case"> <list> <value>yma16</value> <value>2020</value> </list> </property> <property name="set_case"> <set> <value>I am a set</value> <value>yma16</value> </set> </property> </bean>
测试结果！
注解方式
Component、Service、Controller、Ropository
- @Component
- @Service
- @Controller
- @Ropository
注解方式可以类、方法和属性名上面
@注解(value="");<!-- 对应 bean标签中 id唯一标识 -->
- 引入依赖aop
- 开启组件扫描
- 引入命名空间context
创建一个Demo类，component方式创建对象
package context_demo; import org.springframework.stereotype.Component; @Component(value="component1") public class Demo { }
System.out.println("component方式注入"); ApplicationContext context5= new ClassPathXmlApplicationContext("bean05.xml"); Demo compnent1=context5.getBean("component1", Demo.class); System.out.println(compnent1);
<context:component-scan base-package="context_demo"> </context:component-scan>
component方式注入成功！
基于注解方式的属性注入
Autowired、Qualifier、Resource
注入
- Autowired(属性类型)
- Qualifier(属性名称)
- Resource(属性类型或属性名称)
- value(普通类型属性)
代码：去我的仓库
end
