10Spring之IOC容器
IOC容器
1概念和原理
什么是IOC
- 控制反转：把对象创建和对象之间的调用过程，交给Spring进行管理
- 使用IOC目的：为了耦合度降低
- 之前入门案例就是IOC实现
IOC底层原理
- xml解析，工厂模式，反射
IOC容器
- IOC容器基于工厂模式完成，IOC容器底层就是对象工厂
- Spring 提供 IOC 容器实现两种方式：（两个接口）
- BeanFactory：IOC 容器基本实现，是 Spring 内部的使用接口，不提供开发人员进行使用，加载配置文件时候不会创建对象，在获取对象（使用）才去创建对象
- ApplicationContext：BeanFactory 接口的子接口，提供更多更强大的功能，一般由开发人员进行使用，加载配置文件时候就会把在配置文件对象进行创建
- ApplicationContext接口有实现类：FileSystemXmlApplicationContext和ClassPathXmlApplicationContext
2IOC操作Bean管理（概念）
什么是Bean管理
- Bean 管理指的是两个操作
- Spring创建对象
- Spring注入属性
Bean管理操作有两种方式
- 基于 xml 配置文件方式实现
- 基于注解方式实现
3IOC操作Bean管理（基于xml方式）
3.1基于xml方式创建对象
-
在 spring 配置文件中，使用 bean 标签，标签里面添加对应属性，就可以实现对象创建
-
在 bean 标签有很多属性，介绍常用的属性
-
id属性：唯一标识
-
class属性：类全路径（包类路径）
-
创建对象时候，默认也是执行无参数构造方法完成对象创建
<!-- 配置User对象创建 -->
<bean id="user" class="com.fao.pojo.User"></bean>
3.2基于xml方式注入属性
- 第一种注入方式：使用set方法进行注入
- 第二种注入方式：使用有参构造进行注入
- 第三种注入方式：使用p名称空间注入（了解）
3.2.1使用set方法进行注入
//创建类，定义属性和对应的set方法
//演示使用set方法进行注入属性
public class Book {
//创建属性
private String bname;
private String bauthor;
private String address;
//创建属性对应的方法
public void setBname(String bname) {
this.bname = bname;
}
public void setBauthor(String bauthor) {
this.bauthor = bauthor;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Book{" +
"bname='" + bname + '\'' +
", bauthor='" + bauthor + '\'' +
", address='" + address + '\'' +
'}';
}
}
<!-- 在spring配置文件配置对象创建，配置属性注入 -->
<!-- set方法注入属性 -->
<bean id="book" class="com.fao.pojo.Book">
<!-- 使用property完成属性注入
name:类里面属性名称
value:向属性注入的值
-->
<property name="bname" value="jianai"></property>
<property name="bauthor" value="aosiding"></property>
<!-- 设置一个空值 -->
<!-- <property name="address">-->
<!-- <null></null>-->
<!-- </property>-->
<!-- 属性值包含特殊符号 -->
<!-- 方法一转义 -->
<!-- <property name="address" value="<南京>"></property>-->
<!--把特殊符号写到CDATA -->
<property name="address">
<value><![CDATA[<南京>]]></value>
</property>
</bean>
//测试
@Test
public void test2(){
//1加载spring配置文件
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
//获取配置创建的对象
Book book = context.getBean("book", Book.class);
System.out.println(book);
}
3.2.2使用有参构造进行注入
//创建类，定义属性和对应的有参构造
//使用有参数的构造注入
public class Orders {
private String oname;
private String oddress;
//有参数构造
public Orders(String oname, String oddress) {
this.oname = oname;
this.oddress = oddress;
}
@Override
public String toString() {
return "Orders{" +
"oname='" + oname + '\'' +
", oddress='" + oddress + '\'' +
'}';
}
}
<!-- 在spring配置文件配置对象创建，配置属性注入 -->
<!-- 有参数构造注入属性 -->
<bean id="orders" class="com.fao.pojo.Orders">
<constructor-arg name="oname" value="computer"></constructor-arg>
<constructor-arg name="oddress" value="china"></constructor-arg>
<!-- 也可以通过索引值来改变 -->
<!--<constructor-arg index="0" value="手机"></constructor-arg>-->
</bean>
//测试
@Test
public void test3(){
//1加载spring配置文件
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
//获取配置创建的对象
Orders orders = context.getBean("orders", Orders.class);
System.out.println(orders);
}
3.2.3使用p名称空间注入（了解）
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="book" class="com.fao.pojo.Book" p:bname="pp" p:bauthor="faop" p:address="shanghaipp"></bean>
</beans>
//测试，实体类用的还是之前的Book
@Test
public void test4(){
//1加载spring配置文件
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
//获取配置创建的对象
Book book = context.getBean("book", Book.class);
System.out.println(book);
}
3.3基于xml方式注入其他类型属性
3.3.1null值和包含特殊符号的值（上面有了）
<property name="bname" value="jianai"></property>
<property name="bauthor" value="aosiding"></property>
<!-- 设置一个空值 -->
<!-- <property name="address">-->
<!-- <null></null>-->
<!-- </property>-->
<!-- 属性值包含特殊符号 -->
<!-- 方法一转义 -->
<!-- <property name="address" value="<南京>"></property>-->
<!--把特殊符号写到CDATA -->
<property name="address">
<value><![CDATA[<南京>]]></value>
</property>
3.3.2注入外部bean
- 创建两个类service类和dao类
- 在service调用dao里面的方法
- 在spring配置文件中进行配置
//dao层--UserDao
public interface UserDao {
void update();
}
//dao层--UserDaoImpl
public class UserDaoImpl implements UserDao{
@Override
public void update() {
System.out.println("dao update.....");
}
}
//service层--UserService
public class UserService {
//1创建userdao类型属性，生成set方法
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void add(){
System.out.println("service add..........");
userDao.update();
}
}
<!-- bean.xml配置 -->
<!-- 1service和dao对象创建 -->
<bean id="userService" class="com.fao.service.UserService">
<!-- 2注入userDao对象
name属性值：类里面属性名称
ref属性:创建userDao对象bean标签id值
-->
<property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.fao.dao.UserDaoImpl"></bean>
//测试
@Test
public void test5(){
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
UserService userService = context.getBean("userService", UserService.class);
userService.add();
}
3.3.3注入内部bean
- 一对多关系：部门和员工，部门是一，员工是多
- 在实体类之间表示一对多关系，员工表示所属部门，使用对象类型属性进行表示
//部门类
public class Dept {
private String dname;
public void setDname(String dname) {
this.dname = dname;
}
@Override
public String toString() {
return "Dept{" +
"dname='" + dname + '\'' +
'}';
}
}
//员工类
public class Emp {
private String ename;
private String gender;
//员工属于某一个部门，使用对象形式表示
private Dept dept;
public Dept getDept() {
return 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 add(){
System.out.println(ename+" "+gender+" "+dept);
}
}
<!-- 内部bean -->
<bean id="emp" class="com.fao.spring5.bean.Emp">
<!-- 设置两个普通属性 -->
<property name="ename" value="lucy"></property>
<property name="gender" value="女"></property>
<!-- 设置对象类型属性 -->
<property name="dept">
<!-- 内部bean格式 -->
<bean id="dept" class="com.fao.spring5.bean.Dept">
<property name="dname" value="安保部"></property>
</bean>
</property>
</bean>
//测试
@Test
public void tesdBean3(){
ApplicationContext context=new ClassPathXmlApplicationContext("bean3.xml");
Emp emp = context.getBean("emp", Emp.class);
emp.add();
}
3.3.4注入集合属性
- 注入数据类型属性
- 注入List集合类型属性
- 注入Map集合类型属性
//course类
public class Course {
private String cname;
public void setCname(String cname) {
this.cname = cname;
}
@Override
public String toString() {
return "Course{" +
"cname='" + cname + '\'' +
'}';
}
}
//创建类，定义数组，list,map,set类型属性，生成对应的set方法
public class Stu {
//1数组类型属性
private String[] courses;
//2list集合类型属性
private List<String> list;
//3map集合类型属性
private Map<String ,String> maps;
//4set集合类型属性
private Set<String> sets;
//学生所学多门课程
private List<Course> courseList;
public void setCourses(String[] courses) {
this.courses = courses;
}
public void setList(List<String> list) {
this.list = list;
}
public void setMaps(Map<String, String> maps) {
this.maps = maps;
}
public void setSets(Set<String> sets) {
this.sets = sets;
}
public void setCourseList(List<Course> courseList) {
this.courseList = courseList;
}
public void test(){
System.out.println(Arrays.toString(courses));
System.out.println(list);
System.out.println(maps);
System.out.println(sets);
System.out.println(courseList);
}
}
<!-- 在spring配置文件中进行配置 -->
<!-- 集合类型属性注入-->
<bean id="stu" class="com.fao.spring5.collectiontype.Stu">
<!-- 数组类型属性注入 -->
<property name="courses" >
<array>
<value>java课程</value>
<value>数据库课程</value>
</array>
</property>
<!-- list类型属性注入 -->
<property name="list">
<list>
<value>张三</value>
<value>小三</value>
</list>
</property>
<!-- map类型属性注入 -->
<property name="maps">
<map>
<entry key="JAVA" value="java"></entry>
<entry key="PHP" value="php"></entry>
</map>
</property>
<!-- set类型注入 -->
<property name="sets">
<set>
<value>Mysql</value>
<value>Redis</value>
</set>
</property>
<!-- 注入list集合类型，值是对象 -->
<property name="courseList">
<list>
<ref bean="course1"></ref>
<ref bean="course2"></ref>
</list>
</property>
</bean>
<!-- 外部bean 创建多个course对象 -->
<bean id="course1" class="com.fao.spring5.collectiontype.Course">
<property name="cname" value="Spring5"></property>
</bean>
<bean id="course2" class="com.fao.spring5.collectiontype.Course">
<property name="cname" value="MyBatis"></property>
</bean>
@Test
public void testCollection(){
ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
Stu stu = context.getBean("stu", Stu.class);
stu.test();
}
3.3.5注入集合属性改良之把集合注入部分提取出来(xmlns:util)
//Book类
public class Book {
private List<String> list;
public void setList(List<String> list) {
this.list = list;
}
public void test(){
System.out.println(list);
}
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
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/util http://www.springframework.org/schema/util/spring-util.xsd">
<!--1提取list集合类型属性注入 -->
<util:list id="book.list">
<value>易筋经</value>
<value>九阴真经</value>
<value>九阳神功</value>
</util:list>
<!--2提取List集合类型属性注入使用 -->
<bean id="book" class="com.fao.spring5.collectiontype.Book">
<property name="list" ref="book.list"></property>
</bean>
</beans>
@Test
public void testCollection2(){
ApplicationContext context=new ClassPathXmlApplicationContext("bean2.xml");
Book book = context.getBean("book", Book.class);
book.test();
}
3.3.6FactoryBean
- Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean）
- 普通 bean：在配置文件中定义 bean 类型就是返回类型
- 工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样
- 第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean
- 第二步 实现接口里面的方法，在实现的方法中定义返回的 bean 类型
//创建类
public class MyBean implements FactoryBean<Course> {
//定义返回bean
@Override
public Course getObject() throws Exception {
Course course=new Course();
course.setCname("ab");
//注意这边返回的是course，不是MyBean
return course;
}
@Override
public Class<?> getObjectType() {
return null;
}
@Override
public boolean isSingleton() {
return FactoryBean.super.isSingleton();
}
}
<bean id="myBean" class="com.fao.spring5.factorybean.MyBean"></bean>
//测试
@Test
public void test3(){
ApplicationContext context=new ClassPathXmlApplicationContext("bean3.xml");
Course myBean = context.getBean("myBean", Course.class);
System.out.println(myBean);
}
//结果：Course{cname='ab'}
3.4bean作用域
- 在 Spring 里面，设置创建 bean 实例是单实例还是多实例
- 在 Spring 里面，默认情况下，bean 是单实例对象
@Test
public void testDanLiDuoLi4(){
ApplicationContext context=new ClassPathXmlApplicationContext("bean2.xml");
Book book1 = context.getBean("book", Book.class);
Book book2 = context.getBean("book", Book.class);
System.out.println(book1);//com.fao.spring5.collectiontype.Book@b2c9a9c
System.out.println(book2);//com.fao.spring5.collectiontype.Book@b2c9a9c证明是单实例
//在配置文件中加上scope="prototype上面就变成多实例的，两个就不一样了
}
- 在 spring 配置文件 bean 标签里面有属性（scope）用于设置单实例还是多实例
- scope 属性值，第一个值 默认值，singleton，表示是单实例对象；第二个值 prototype，表示是多实例对象
<bean id="book" class="com.fao.spring5.collectiontype.Book" scope="prototype">
<property name="list" ref="bookList"></property>
</bean>
3.5bean生命周期
生命周期
- 从对象创建到对象销毁的过程
bean生命周期(基本五步)
- 通过构造器创建 bean 实例（无参数构造）
- 为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
- 调用 bean 的初始化的方法（需要进行配置初始化的方法）
- bean 可以使用了（对象获取到了）
- 当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）
bean生命周期加上后置处理器（七步，在初始化前又加了两步）
- 通过构造器创建 bean 实例（无参数构造）
- 为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）
- 把 bean 实例传递 bean 后置处理器的方法 postProcessBeforeInitialization
- 调用 bean 的初始化的方法（需要进行配置初始化的方法）
- 把 bean 实例传递 bean 后置处理器的方法 postProcessAfterInitialization
- bean 可以使用了（对象获取到了）
- 当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）
public class Orders {
//无参构造
public Orders() {
System.out.println("第一步 执行无参数构造器创建bean实例");
}
private String oname;
public void setOname(String oname) {
this.oname = oname;
System.out.println("第二步 调用set方法设置属性值");
}
//创建执行的初始化方法
public void initMethod(){
System.out.println("第三步 执行初始化的方法");
}
//创建执行的销毁方法
public void destroyMethod(){
System.out.println("第五步 执行销毁方法");
}
}
//后置处理器，需要implements BeanPostProcessor
public class MyBeanPost implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("在初始化之前执行的方法");
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("在初始化之后执行的方法");
return bean;
}
}
<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="orders" class="com.fao.spring5.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
<property name="oname" value="手机"></property>
</bean>
<!--配置后置处理器 会为当前配置文件中所有实例都添加后置处理器 -->
<bean id="myBeanPost" class="com.fao.spring5.bean.MyBeanPost"></bean>
</beans>
//测试
@Test
public void testBean5(){
ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("bean4.xml");
Orders orders = context.getBean("orders", Orders.class);
System.out.println("第四步 获取创建bean实例对象");
System.out.println(orders);
//手动让bean实例销毁
context.close();
}
//结果
/*
第一步 执行无参数构造器创建bean实例
第二步 调用set方法设置属性值
在初始化之前执行的方法
第三步 执行初始化的方法
在初始化之后执行的方法
第四步 获取创建bean实例对象
com.fao.spring5.bean.Orders@51399530
第五步 执行销毁方法
*/
3.6xml自动装配
- 根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入
//Dept类
public class Dept {
private String name;
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Dept{" +
"name='" + name + '\'' +
'}';
}
}
//Emp类
public class Emp {
private Dept dept;
public void setDept(Dept dept) {
this.dept = dept;
}
@Override
public String toString() {
return "Emp{" +
"dept=" + dept +
'}';
}
public void test(){
System.out.println(dept);
}
}
<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--自动装配
bean标签属性autowire，配置自动装配
常用两个值：
byName根据属性名称注入，注入值bean的id值要和类属性名称一样（用的更多）
byType根据属性类型注入，相同类型的bean不能定义多个
-->
<bean id="emp" class="com.fao.spring5.autowire.Emp" autowire="byName">
<!-- 手动装配，注意下面ref的dept就是Emp里面定义的dept -->
<!-- <property name="dept" ref="dept"></property> -->
</bean>
<bean id="dept" class="com.fao.spring5.autowire.Dept">
<property name="name" value="IT"></property>
</bean>
</beans>
//测试
@Test
public void test6(){
ApplicationContext context=new ClassPathXmlApplicationContext("bean5.xml");
Emp emp = context.getBean("emp", Emp.class);
System.out.println(emp);
}
//结果：Emp{dept=Dept{name='IT'}}
3.7外部属性文件
3.7.1配置数据库信息
- 配置德鲁伊连接池
3.7.2方式一，直接配置数据库信息
<!-- 直接配置连接池 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<!-- 配置连接池 -->
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/test"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
3.7.3方式二，引入外部属性文件配置数据库连接池（掌握）
- 创建外部属性文件，properties 格式文件，写数据库信息
- 把外部 properties 属性文件引入到 spring 配置文件中,引入 context 名称空间
prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/test
prop.userName=root
prop.password=root
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:util="http://www.springframework.org/schema/util"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<!-- 先引入外部属性文件-->
<context:property-placeholder location="jdbc.properties"></context:property-placeholder>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<!-- 配置连接池 -->
<property name="driverClassName" value="${prop.driverClass}"></property>
<property name="url" value="j${prop.url}"></property>
<property name="username" value="${prop.userName}"></property>
<property name="password" value="${prop.password}"></property>
</bean>
</beans>
4IOC操作Bean管理（基于注解方式）
4.1什么是注解
- 注解是代码特殊标记，格式：@注解名称(属性名称=属性值, 属性名称=属性值..)
- 使用注解，注解作用在类上面，方法上面，属性上面
- 使用注解目的：简化 xml 配置
4.2spring针对Bean管理中创建对象提供注解
- @Component
- @Service
- @Controller
- @Repository
- 上面四个注解功能是一样的，都可以用来创建bean实例
4.3第一次使用
- 开启组件扫描
<?xml version="1.0" encoding="gbk"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
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">
<!-- 开启组件扫描
1扫描多个包，用逗号隔开
2扫描包上层目录
-->
<context:component-scan base-package="com.fao.bean,com.fao.service"></context:component-scan>
</beans>
- 创建类，在类上面添加创建对象注解
//在注解里面value属性值可以不写，默认值就是类名称，首字母小写
//UserService->userService
//@Controller(value = "userService")//<bean id="userService" class="..">
@Service
public class UserService {
private String name;
public void add(){
System.out.println("UserService add.....");
}
}
- 测试
public class MyTest {
@Test
public void test1(){
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
UserService userService = context.getBean("userService", UserService.class);
userService.add();
}
}
4.4开启组件扫描细节配置
<!-- 实例一
use-default-filters="false"：不使用默认的filter
context:include-filter:设置扫描的内容
下面那意思是扫描带Controller的注解
-->
<context:component-scan base-package="com.fao" use-default-filters="false">
<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!-- 实例二
context:exclude-filter：那些内容不进行扫描 和上面正好相反
-->
<context:component-scan base-package="com.fao">
<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
4.5基于注解方式实现属性注入
-
第一步 把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解
-
第二步 在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解
-
@Autowired：根据属性类型进行自动装配
-
@Qualifier：根据名称进行注入，这个@Qualifier 注解的使用，和上面@Autowired 一起使用
-
@Resource：可以根据类型注入，可以根据名称注入，上面都不加就算根据类型学注入，括号里面加name=""就是名称输入
-
@Value：注入普通类型属性
//dao层
public interface UserDao {
public void add();
}
//dao层实现类
@Repository(value = "userDaoImpl1")
public class UserDaoImpl implements UserDao{
@Override
public void add() {
System.out.println("UserDao add....");
}
}
//service层
//在注解里面value属性值可以不写，默认值就是类名称，首字母小写
//UserService->userService
@Controller(value = "userService")//<bean id="userService" class="..">
@Service
public class UserService {
//定义dao类型属性
//不需要添加set方法
//添加注入属性注解
@Autowired //根据类型注入 但如果有多个类型实现类就很难找
@Qualifier(value = "userDaoImpl1")//根据名称
private UserDao userDao;
// @Resource //根据类型注入
// @Resource(name = "userDaoImpl1") //根据名称注入
// 因为不是spring包下 所以更建议上面两个
// private UserDao userDao;
@Value(value = "Abc")
private String name;
public void add(){
System.out.println("UserService add.....");
userDao.add();
System.out.println(name);
}
}
//测试
@Test
public void testService1(){
ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
UserService userService = context.getBean("userService", UserService.class);
System.out.println(userService);
userService.add();
}
//结果
/*
com.fao.spring5.service.UserService@294425a7
UserService add.....
UserDao add....
Abc
*/
4.6完全注解开发
- 两处不一样
- 实体类上面@Configuration ，创建配置类 替代xml配置文件
- ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
@Configuration //创建配置类 替代xml配置文件
@ComponentScan(basePackages = {"com.fao"})
public class SpringConfig {
}
//完全注解
@Test
public void testService2(){
//注意这里不一样
ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
UserService userService = context.getBean("userService", UserService.class);
System.out.println(userService);
userService.add();
}
浙公网安备 33010602011771号