今天开始学习我自己总结的 Java-学习路线 中的《Spring-IOC》,小简从 0 开始学 Java 知识,并不定期更新所学笔记,期待一年后的蜕变吧
Spring 总共大约有 20 个模块, 由 1300 多个不同的文件构成。
下载完成后解压,解压后的文件目录结构如下所示:
.
├── docs #API文档和开发规范
├── libs #开发需要的JAR包和源码
├── license.txt
├── notice.txt
├── readme.txt
└── schema #开发所需要的schema文件
libs 目录中的 JAR 包分为三类
整个 Spring 框架由大约 20 个模块组成,该目录下 Spring 为每个模块都提供了这三类压缩包。
使用 Spring 开发时,除了要使用自带的JAR包外,Spring的核心容器还需要依赖 commons.logging 的JAR包。
在 libs目录中,有四个 Spring 的基础包,分别对应 Spring 核心容器的四个模块。
初学者学习 Sping 框架时,只需将 Sping 的 4 个基础包以及 commons-logging-1.2.jar 复制到项目的 lib 目录,并发布到类路径中即可。
.
├── commons-logging-1.2.jar
├── spring-beans-5.3.18.jar
├── spring-context-5.3.18.jar
├── spring-core-5.3.18.jar
└── spring-expression-5.3.18.jar
public class User {
public void add(){
System.out.println("add.......");
}
}
<?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">
<!--配置User对象创建-->
<bean id="user" class="com.jwt.User"/>
</beans>
public class BeanTest {
@Test
public void testAdd() {
//1 加载 spring 配置文件
ApplicationContext context =
new ClassPathXmlApplicationContext("bean1.xml");
//2 获取配置创建的对象
User user = context.getBean("user", User.class);
System.out.println(user);
user.add();
}
}
/**
com.jwt.User@6950e31
add.......
**/
Spring 提供 IOC 容器两种实现方式:(两个接口)
ApplicationContext 接口实现类
Spring 有两种类型 Bean,一种是普通 Bean,另外一种是工厂 Bean(FactoryBean)
在配置文件中定义bean类型就是返回类型
public class MyBean {
}
<!--普通bean-->
<bean id="myBean" class="com.jwt.MyBean"></bean>
@Test
public void testBean() {
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("bean.xml");
MyBean bean = context.getBean("myBean", MyBean.class);
System.out.println(bean);
}
//com.jwt.MyBean@49c43f4e
工厂Bean:在配置文件定义 bean 类型可以和返回类型不一致
第一步:创建类,让这个类作为工厂Bean,实现接口FactoryBean
第二步:实现接口里面的方法,在实现的方法中定义返回的Bean类型
public class MyBean implements FactoryBean<Course> {
// 定义返回Bean类型的对象
@Override
public Course getObject() throws Exception {
Course course = new Course();
course.setCname("工厂bean");
return course;
}
// 得到对象类型
@Override
public Class<?> getObjectType() {
return null;
}
// 是否是单例模式
@Override
public boolean isSingleton() {
return false;
}
}
<!--工厂bean-->
<bean id="myBean" class="com.jwt.MyBean"></bean>
@Test
public void testFactoryBean() {
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("bean.xml");
Course bean = context.getBean("myBean", Course.class);
System.out.println(bean);
}
//Course{cname='工厂bean'}
在 Spring 里面,设置创建 Bean 实例是单实例还是多实例,默认情况下,Bean 是单实例对象
证明:创建二个 Bean 的实例对象,实例对象的地址相同说明是同一对象,也就是 Bean 是单例对象
<bean id="book" class="com.jwt.ioc.Book">
<property name="bname" value="小明"></property>
<property name="bauthor" value="小简"></property>
</bean>
@Test
public void test() {
ApplicationContext context =
new ClassPathXmlApplicationContext ("bean3.xml") ;
Book book1 = context.getBean("book" , Book.class);
Book book2 = context.getBean("book" , Book.class);
System.out.println (book1);
System.out.println (book2);
}
/**相同
com.jwt.ioc.Book@548ad73b
com.jwt.ioc.Book@548ad73b
**/
如何设置单实例还是多实例
singleton和prototype区别
<bean id="book" class="com.jwt.ioc.Book" scope="prototype">
<property name="bname" value="小明"></property>
<property name="bauthor" value="小简"></property>
</bean>
@Test
public void test() {
ApplicationContext context =
new ClassPathXmlApplicationContext ("bean3.xml") ;
Book book1 = context.getBean("book" , Book.class);
Book book2 = context.getBean("book" , Book.class);
System.out.println (book1);
System.out.println (book2);
}
/**不相同
com.jwt.ioc.Book@eb21112
com.jwt.ioc.Book@2eda0940
**/
Bean生命周期:从对象创建到对象销毁的过程
演示Bean生命周期
public class Orders {
private String oname;
public Orders() {
System.out.println("第一步 执行无参构造器创建bean实例");
}
public void setOname(String oname) {
System.out.println("第二步 调用set方法设置属性值");
this.oname = oname;
}
// 创建执行的初始化方法
public void initMethod() {
System.out.println("第三步 执行初始化方法");
}
// 创建执行的销毁方法
public void destroyMethod(){
System.out.println("第五步 执行销毁方法");
}
}
<!--bean声明周期-->
<bean id="orders" class="com.jwt.ioc.Orders" init-method="initMethod" destroy-method="destroyMethod">
<property name="oname" value="电脑"/>
</bean>
@Test
public void testBeanLive() {
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("bean5.xml");
Orders bean = context.getBean("orders", Orders.class);
System.out.println("第四步 获取创建bean实例的对象"+bean);
context.close();// 手动让bean销毁
}
/**
第一步 执行无参构造器创建bean实例
第二步 调用set方法设置属性值
第三步 执行初始化方法
第四步 获取创建bean实例的对象com.jwt.ioc.Orders@954b04f
第五步 执行销毁方法
**/
如果有bean后置处理器,则bean的生命周期有七种
配置后置处理器,实现 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;
}
}
<!--配置后置处理器 配置之后会为所有的bean实例添加后置处理器-->
<bean id="myBeanPost" class="com.jwt.ioc.MyBeanPost"></bean>
@Test
public void testBeanLive() {
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("bean5.xml");
Orders bean = context.getBean("orders", Orders.class);
System.out.println("第四步 获取创建bean实例的对象"+bean);
context.close();// 手动让bean销毁
}
/**
第一步 执行无参构造器创建bean实例
第二步 调用set方法设置属性值
在初始化之前执行的方法
第三步 执行初始化方法
在初始化之后执行的方法
第四步 获取创建bean实例的对象com.jwt.ioc.Orders@481a15ff
第五步 执行销毁方法
**/
1、在spring配置文件中,使用 bean 标签,标签里面添加对应属性,就可以实现对象创建
2、在bean标签有很多属性,常用的属性:
3、创建对象时候,默认也是执行无参数构造方法完成对象创建
<!--配置User对象创建-->
<bean id="user" class="com.jwt.User"></bean>
基于 xml 注入属性就是依赖注入(DI)
Step1:创建类,定义属性和对应的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;
}
@Override
public String toString() {
return "Book{" +
"bname='" + bname + '\'' +
", bauthor='" + bauthor + '\'' +
'}';
}
}
Step2:配置xml文件创建对象,用 property 标签注入属性
<bean id="book" class="com.jwt.ioc.Book">
<!--使用property完成属性注入
name:类里面属性名称
value:向属性注入的值 -->
<property name="bname" value="Java入门到精通"></property>
<property name="bauthor" value="小简"></property>
</bean>
Step3:测试
public class BookTest {
@Test
public void test(){
//1 加载 spring 配置文件
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("bean2.xml");
//2 获取配置创建的对象
Book book = context.getBean("book", Book.class);
System.out.println(book);
}
}
//Book{bname='Java入门到精通', bauthor='小简'}
Step1:创建类,定义属性,创建属性对应有参数构造方法
public class Order {
private String oname;
private String address;
public Order(String oname, String address) {
this.oname = oname;
this.address = address;
}
@Override
public String toString() {
return "Order{" +
"oname='" + oname + '\'' +
", address='" + address + '\'' +
'}';
}
}
Step2:配置xml文件创建对象
<bean id="order" class="com.jwt.ioc.Order">
<!--通过属性名称注入-->
<constructor-arg name="oname" value="电脑"></constructor-arg>
<constructor-arg name="address" value="China"></constructor-arg>
<!--通过索引名称注入-->
<!--<constructor-arg index="0" value="平板"></constructor-arg>-->
<!--<constructor-arg index="1" value="china"></constructor-arg>-->
</bean>
Step3:测试
public class OrderTest {
@Test
public void test(){
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("bean2.xml");
Order order = context.getBean("order", Order.class);
System.out.println(order);
}
}
//Order{oname='电脑', address='China'}
使用p名称空间注入,可以简化基于 xml 配置方式
Step1:添加p名称空间到配置文件中xmlns:p="http://www.springframework.org/schema/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">
</beans>
Step2:通过p标签进行属性注入
<bean id="book" class="com.jwt.ioc.Book" p:bname="Spring入门" p:bauthor="无名氏"></bean>
设置空值:在属性property里使用null标签实现
<bean id="book" class="com.jwt.ioc.Book">
<property name="bname" value="Spring学习"/>
<!--设置null值-->
<property name="bauthor">
<null></null>
</property>
</bean>
<!--Book{bname='Spring学习', bauthor='null'}-->
设置特殊符号:在属性property里使用 value 标签通过 <![CDATA[xxx]]> 实现
<bean id="book" class="com.jwt.ioc.Book">
<property name="bname" value="Spring学习"/>
<property name="bauthor">
<value><![CDATA[<<西游记>>]]></value>
</property>
</bean>
<!--Book{bname='Spring学习', bauthor='<<西游记>>'}-->
场景:service层调用dao层
Step1:创建两个类 service类和dao类
package com.jwt.Service;
import com.jwt.dao.UserDao;
import com.jwt.dao.UserDaoImpl;
public class UserService {//service类
//创建UserDao类型属性,生成set方法
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void add() {
System.out.println("service add...............");
//传统方法
//UserDao userDao = new UserDaoImpl();
//userDao.update();
this.userDao.update();//调用dao方法
}
}
package com.jwt.dao;
public interface UserDao {
public void update();
}
package com.jwt.dao;
public class UserDaoImpl implements UserDao {//dao类
@Override
public void update() {
System.out.println("dao update...........");
}
}
Step2:在spring配置文件中进行配置,使用属性property的ref注入外部对象
<!--service和dao对象创建-->
<bean id="userService" class="com.jwt.Service.UserService">
<!--注入userDao对象
name属性:类里面的属性名称
ref属性:创建userDao对象bean标签id值
-->
<property name="userDao" ref="userDaoImpl"></property>
</bean>
<bean id="userDaoImpl" class="com.jwt.dao.UserDaoImpl"></bean>
Step3:测试
package com.jwt.testdemo;
public class BeanTest {
@Test
public void test(){
//1 加载 spring 配置文件
ApplicationContext context =
new ClassPathXmlApplicationContext("bean2.xml");
//2 获取配置创建的对象
UserService userService = context.getBean("userService", UserService.class);
userService.add();
}
}
/**
service add...............
dao update...........
**/
(1)一对多关系:部门和员工,一个部门有多个员工,一个员工属于一个部门 (2)在实体类之间表示一对多关系,员工表示所属部门,使用对象类型属性进行表示
Step1:创建部门和员工类
public class Department {
private String dname;
public void setDname(String dname) {
this.dname = dname;
}
@Override
public String toString() {
return "Department{" +
"dname='" + dname + '\'' +
'}';
}
}
public class Employee {
private String ename;
private String gender;
//员工属于某一个部门,使用对象形式表示
private Department dept;
public Department getDept() {//级联注入第二种需要这个方法
return dept;
}
public void setDept(Department dept) {
this.dept = dept;
}
public void setEname(String ename) {
this.ename = ename;
}
public void setGender(String gender) {
this.gender = gender;
}
@Override
public String toString() {
return "Employee{" +
"ename='" + ename + '\'' +
", gender='" + gender + '\'' +
", dept=" + dept +
'}';
}
}
Step2:在 spring配置文件中进行配置
<bean id="emp" class="com.jwt.ioc.Employee">
<!--设置两个普通属性-->
<property name="ename" value="lucy"></property>
<property name="gender" value="女"></property>
<!--设置对象类型属性-->
<property name="dept">
<bean id="dept" class="com.jwt.ioc.Department">
<property name="dname" value="安保部"></property>
</bean>
</property>
</bean>
<!--级联赋值-->
<bean id="emp" class="com.jwt.ioc.Employee">
<!--设置两个普通属性-->
<property name="ename" value="lucy"></property>
<property name="gender" value="女"></property>
<!--级联赋值-->
<property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.jwt.ioc.Department">
<property name="dname" value="财务部"></property>
</bean>
<!--级联赋值-->
<bean id="emp" class="com.jwt.ioc.Employee">
<!--设置两个普通属性-->
<property name="ename" value="lucy"></property>
<property name="gender" value="女"></property>
<!--级联赋值-->
<property name="dept" ref="dept"></property>
<property name="dept.dname" value="技术部"></property>
</bean>
<bean id="dept" class="com.jwt.ioc.Department">
<property name="dname" value="财务部"></property>
</bean>
Step3:测试
public class BeanTest {
@Test
public void test2(){
//1 加载 spring 配置文件
ApplicationContext context =
new ClassPathXmlApplicationContext("bean4.xml");
//2 获取配置创建的对象
Employee emp = context.getBean("emp", Employee.class);
System.out.println(emp);
}
}
//写法1:Employee{ename='lucy', gender='女', dept=Department{dname='安保部'}}
//写法2:Employee{ename='lucy', gender='女', dept=Department{dname='财务部'}}
//写法3:Employee{ename='lucy', gender='女', dept=Department{dname='技术部'}}
Step1:创建类,定义数组、list、set、map类型属性,生成对应set方法
package com.jwt.ioc;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Stu {
//1 数组类型属性
private String[] courses;
// 2 list集合类型属性
private List<String> list;
// 3 set集合类型属性
private Set<String> sets;
// 4 map集合类型属性
private Map<String, String> maps;
public void setCourses(String[] courses) {
this.courses = courses;
}
public void setList(List<String> list) {
this.list = list;
}
public void setSets(Set<String> sets) {
this.sets = sets;
}
public void setMaps(Map<String, String> maps) {
this.maps = maps;
}
@Override
public String toString() {
return "Stu{" +
"courses=" + Arrays.toString(courses) +
", list=" + list +
", maps=" + maps +
", sets=" + sets +
'}';
}
}
Step2:在spring配置文件进行配置
<bean id="stu" class="com.jwt.ioc.Stu">
<!--数组类型属性注入-->
<property name="courses">
<array>
<value>Spring课程</value>
<value>Mybatis课程</value>
</array>
</property>
<!--list类型属性注入-->
<property name="list">
<list>
<value>测试1</value>
<value>测试2</value>
</list>
</property>
<!--set类型属性注入-->
<property name="sets">
<set>
<value>data1</value>
<value>data2</value>
</set>
</property>
<!--map类型属性注入-->
<property name="maps">
<map>
<entry key="语言1" value="Java"></entry>
<entry key="语言2" value="C++"></entry>
</map>
</property>
</bean>
Step3:测试
public class BeanTest {
@Test
public void test(){
//1 加载 spring 配置文件
ApplicationContext context =
new ClassPathXmlApplicationContext("bean5.xml");
//2 获取配置创建的对象
Stu stu = context.getBean("stu", Stu.class);
System.out.println(stu);
}
}
//Stu{courses=[Spring课程, Mybatis课程], list=[测试1, 测试2], maps={语言1=Java, 语言2=C++}, sets=[data1, data2]}
一个学生有多门课程
package com.jwt.ioc;
import java.util.List;
public class Stu{
private List<Course> courseList;
public void setCourseList(List<Course> courseList) {
this.courseList = courseList;
}
@Override
public String toString() {
return "Stu{" +
"courseList=" + courseList +
'}';
}
}
package com.jwt.ioc;
public class Course {
private String cname;
public void setCname(String cname) {
this.cname = cname;
}
@Override
public String toString() {
return "Course{" +
"cname='" + cname + '\'' +
'}';
}
}
在spring配置文件进行配置
<!--创建多个course对象-->
<bean id="course1" class="com.jwt.ioc.Course">
<property name="cname" value="Spring5框架"></property>
</bean>
<bean id="course2" class="com.jwt.ioc.Course">
<property name="cname" value="MyBatis框架"></property>
</bean>
<bean id="stu" class="com.jwt.ioc.Stu">
<!--注入list集合类型,值是对象-->
<property name="courseList">
<list>
<ref bean="course1"></ref>
<ref bean="course2"></ref>
</list>
</property>
</bean>
public class Stu{
//list集合类型属性
private List<String> book;
public void setBook(List<String> book) {
this.book = book;
}
@Override
public String toString() {
return "Stu{" +
"book=" + book +
'}';
}
}
Step1:在spring配置文件中引入名称空间 util
<?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:util="http://www.springframework.org/schema/util" <!--添加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 "> <!--添加util名称空间-->
</beans>
Step2:使用util标签完成list集合注入提取
<!--1 提取list集合类型属性注入-->
<util:list id="bookList">
<value>易筋经</value>
<value>九阴真经</value>
<value>九阳神功</value>
</util:list>
<!--2 提取list集合类型属性注入使用-->
<bean id="stu" class="com.jwt.ioc.Stu">
<property name="book" ref="bookList"></property>
</bean>
Step2:测试
public class BeanTest {
@Test
public void test(){
//1 加载 spring 配置文件
ApplicationContext context =
new ClassPathXmlApplicationContext("bean5.xml");
//2 获取配置创建的对象
Stu stu = context.getBean("stu", Stu.class);
System.out.println(stu);
}
}
//Stu{book=[易筋经, 九阴真经, 九阳神功]}
什么是自动装配:根据指定装配规则(属性名称或者属性类型),Spring 自动将匹配的属性值进行注入
实现自动装配:使用 Bean 标签属性 autowire,配置自动装配 autowire 属性常用两个值:
1、根据属性名称自动注入
<bean id="empAuto" class="com.jwt.ioc.Employee" autowire="byName"></bean>
<bean id="deptAuto" class="com.jwt.ioc.Department"></bean>
2、根据属性类型自动注入
<bean id="empAuto" class="com.jwt.ioc.Employee" autowire="byType"></bean>
<bean id="deptAuto" class="com.jwt.ioc.Department"></bean>
场景:配置 druid 数据库连接池
方式一:直接配置数据库信息
1、引入Druid连接池依赖 jar 包
下载地址:https://repo1.maven.org/maven2/com/alibaba/druid/
2、配置Druid(德鲁伊)连接池
<!--直接配置连接池-->
<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/userDb"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
方式二:引入外部配置文件
1、创建外部属性文件 druid.properties,写数据库信息
prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/dbname
prop.username=root
prop.password=root
2、引入 context 名称空间
xmlns:context="http://www.springframework.org/schema/context"和http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
<?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: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">
</beans>
3、把外部 properties 属性文件引入到 Spring 配置文件中 ,${}
取值
<!--引入外部属性文件-->
<context:property-placeholder location="classpath:druid.properties"/>
<!--配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${prop.driverClass}"></property>
<property name="url" value="${prop.url}"></property>
<property name="username" value="${prop.userName}"></property>
<property name="password" value="${prop.password}"></property>
</bean>
上面四个注解功能是一样的,都可以用来创建bean实例
@Service一般用在service层,@Controller一般用在web层,@Repository一般用在dao层
Step1:引入依赖 spring-aop-5.3.18.jar
Step2:开启组件扫描
<!--先引入context名称空间-->
<?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: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">
</beans>
<!--再开启组件扫描-->
<context:component-scan base-package="com.jwt.annotation"/>
Step3:创建类,在类上面添加创建对象注解
@Service(value = "userService")
public class UserService {
public void add() {
System.out.println("annotation service add ...");
}
}
在注解里面 value 属性值可以省略不写,默认值是类名称,首字母小写即UserService-->userService
注解配置等同xml这段配置<bean id="userService" class="...">
<!--开启组件扫描-->
<context:component-scan base-package="com.jwt"/>
上面表示会扫 base-package 下的所有注解,如何配置在 base-package 下哪些类扫描,哪些类不扫描?
配置组件扫描配置的参数:
1、只扫描 base-package下带 Controller 的注解
<context:component-scan base-package="com.jwt" use-default-filters="false">
<context:include-filter type="annotation"
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
2、不扫描 base-package 下带 Controller 的注解
<context:component-scan base-package="com.jwt">
<context:exclude-filter type="annotation"
expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
Step1:把service和dao对象创建,在service和dao类添加创建对象注解
@Service(value = "userService")
public class UserService {
public void add() {
System.out.println("annotation service add ...");
}
}
@Repository(value = "userDao")
public class UserDao {
public void add() {
System.out.println("annotation dao add...");
}
}
Step2:在service注入dao对象,在service类添加dao类型属性,在属性上面使用注解
@Service(value = "userService")
public class UserService {
// 注入userDao对象
@Autowired
private UserDao userDao;//不需要添加set方法
public void add() {
userDao.add();//调用dao方法
System.out.println("annotation service add ...");
}
}
Step3:测试
@Test
public void test(){
//1 加载 spring 配置文件
ApplicationContext context =
new ClassPathXmlApplicationContext("bean.xml");
//2 获取配置创建的对象
UserService userService = context.getBean("userService", UserService.class);
System.out.println(userService);
userService.add();
}
/**
com.jwt.annotation.UserService@12d4bf7e
annotation dao add...
annotation service add ...
**/
这个 @Qualifier 注解的使用,和上面@Autowired 一起使用
使用场景:由于@Autowired注解是按照属性类型进行注入,如果 bean 容器中有多个同一类型的实例对象,就需要使用 @Qualifier 根据实例名称指定注入哪一个实例对象
@Autowired //根据类型进行注入
@Qualifier(value = "userDaoImpl1")//根据名称进行注入
private UserDao userDao;
import javax.annotation.Resource;
@Resource(name = "userDaoImpl1")
private UserDao userDao;
@Value(value = "小明")
private String name;
Step1:创建配置类,替代 xml 配置文件
@Configuration
: 作为配置类 替代xml配置文件
@ComponentScan
: 开启组件扫描
@Configuration
@ComponentScan(basePackages = {"com.jwt"})
public class SpringConfig {
}
Step2:编写测试类
使用AnnotationConfigApplicationContext
加载配置类
@Test
public void test() {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(SpringConfig.class);
UserService userService = context.getBean("userService", UserService.class);
System.out.println(userService);
userService.add();
}
/**
com.jwt.annotation.UserService@6580cfdd
annotation dao add...
annotation service add ...
**/
由于早起开发的系统大部分都是采用xml的形式配置bean,现在的企业级开发基本上不用这种模式了。但是如果你特别幸运,需要基于之前的系统进行二次开发,这就尴尬了。新开发用注解格式,之前开发的是xml格式。这个时候可不是让你选择用哪种模式的,而是两种要同时使用。spring提供了一个注解可以解决这个问题,@ImportResource
,在配置类上直接写上要被融合的xml配置文件名即可,算的上一种兼容性解决方案,没啥实际意义。
@Configuration
@ImportResource("applicationContext1.xml")
public class SpringConfig {
}
前面用到了@Configuration这个注解,当我们使用AnnotationConfigApplicationContext加载配置类的时候,配置类可以不添加这个注解。但是这个注解有一个更加强大的功能,它可以保障配置类中使用方法创建的bean的唯一性。为@Configuration注解设置proxyBeanMethods属性值为true即可,由于此属性默认值为true,所以很少看见明确书写的,除非想放弃此功能。
@Configuration(proxyBeanMethods = true)
public class SpringConfig {
@Bean
public Cat cat(){
return new Cat();
}
}
下面通过容器再调用上面的cat方法时,得到的就是同一个对象了。注意,必须使用spring容器对象调用此方法才有保持bean唯一性的特性。此特性在很多底层源码中有应用。
public class App {
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
String[] names = ctx.getBeanDefinitionNames();
for (String name : names) {
System.out.println(name);
}
System.out.println("-------------------------");
SpringConfig springConfig = ctx.getBean("springConfig", SpringConfig.class);
System.out.println(springConfig.cat());
System.out.println(springConfig.cat());
System.out.println(springConfig.cat());
}
}