1.Spring
1.1、简介
2002,首次推出了spring框架的雏形:interface21框架
Spring框架即以interface21框架为基础,经过重新设计,并不断丰富其内涵,于2004年3月24日,发布了1.0正式版。
Rod Johnson ,Spring Framework创始人,著名作者。很难想象Rod Johnson的学历,真的让好多人大吃一惊,他是悉尼大学的博士,然而他的专业不是计算机,而是音乐学。
Spring是一个轻量级的控制反转(IOC)和面向切面编程(AOP)的容器框架。
spring理念:使现有的技术更加容易使用,本身是一个大杂烩,整合了现有的技术框架。
- SSH : Struct2+ Spring+ Hibernate!
- SSM : SpringMvc + Spring + Mybatis!
官网:https://spring.io/projects/spring-framework#learn
官网下载地址:https://repo.spring.io/ui/native/release/org/springframework/spring
GitHub:https://github.com/spring-projects/spring-framework
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.9</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.9</version>
</dependency>
1.2、优点
- spring是一个免费的、开源的框架(容器)
- spring是一个轻量级的、非入侵式的框架
- 控制反转(IOC),面向切面编程(AOP)
- 支持事物的处理,对框架整合的支持
Spring就是一个轻量级的控制反转(IOC)和面向切面编程(AOP)的框架
1.3、组成
spring中的7大模块
Spring的7大模块分别为:spring Core、Spring Context、Spring AOP、Spring ORM、Spring Dao、Spring MVC、spring web,其框架结构如下图所示:
每个模块的功能如下:
spring Core(核心容器):核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory,它是工厂模式的实现。BeanFactory 使用控制反转 (IOC)模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
Spring Context (Spring上下文):一个核心配置文件,为Spring框架提供上下文信息。Spring 上下文包括企业服务,例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
Spring AOP:集成了面向切面的编程功能(AOP把一个业务流程分成几部分,例如权限检查、业务处理、日志记录, 每个部分单独处理,然后把它们组装成完整的业务流程。每个部分被称为切面),
可以将声明性事物管理集成到应用程序中。
Spring DAO:Spring操作数据库的模块。它可消除冗长的JDBC编码和解析数据库厂商特有的错误代码,它可消除冗长的JDBC编码和解析数据库厂商特有的错误代码JDBC DAO 抽象层提供了有意义的异常层次结构,可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理,并且极大地降低了需要编写的异常代码数量(例如打开和关闭连接)。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
Spring ORM:Spring 框架插入了若干个 ORM 框架,从而提供了 ORM 的对象关系工具,其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
Spring Web 模块:集成各种优秀的web层框架的模块。Web 上下文模块建立在应用程序上下文模块之上,为基于 Web 的应用程序提供了上下文。所以,Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
Spring MVC 框架:MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口,MVC 框架变成为高度可配置的,MVC 容纳了大量视图技术,其中包括 JSP、Velocity、Tiles、iText 和 POI。
Spring 框架的功能可以用在任何 J2EE 服务器中,大多数功能也适用于不受管理的环境。Spring 的核心要点是:支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象。毫无疑问,这样的对象可以在不同 J2EE 环境 (Web 或 EJB)、独立应用程序、测试环境之间重用。
1.4、扩展
- SpringBoot
- 一个快速开发的脚手架。
- 基于SpringBoot可以快速的开发单个微服务。
- 约定大于配置!
- SpringCloud
- SpringCloud 是基于SpringBoot实现的。
2、IOC理论推导
1.UserDao接口
package com.ryh.dao;
public interface UserDao {
void getUser();
}
2.UserDaolmpl 实现类
package com.ryh.dao;
public class UserDaoImpl implements UserDao{
public void getUser() {
System.out.println("这是传统的方法");
}
}
3.UserService业务接口
package com.ryh.service;
public interface UserService {
void getUser();
}
4.UserServicelmpl 业务实现类
package com.ryh.service;
import com.ryh.dao.UserDao;
import com.ryh.dao.UserDaoImpl;
public class UserServiceImpl implements UserService{
private UserDao userDao = new UserDaoImpl();
public void getUser() {
userDao.getUser();
}
}
5、测试
package com.ryh;
import com.ryh.service.UserService;
import com.ryh.service.UserServiceImpl;
public class MyTest {
public static void main(String[] args) {
UserService userService = new UserServiceImpl();
userService.getUser();
}
}
用户增加需求
必须增加新的UserMySqlDaolmpl 实现类
package com.ryh.dao;
public class UserMySqlDaoImpl implements UserDao{
public void getUser() {
System.out.println("这是Mysql的方法");
}
}
增加UserMySqlServicelmpl 业务实现类
package com.ryh.service;
import com.ryh.dao.UserDao;
import com.ryh.dao.UserDaoImpl;
public class UserMySqlServiceImpl implements UserService{
private UserDao userDao = new UserMySqlDaoImpl();
public void getUser() {
userDao.getUser();
}
}
修改测试
package com.ryh;
import com.ryh.service.UserService;
import com.ryh.service.UserServiceImpl;
public class MyTest {
public static void main(String[] args) {
UserService userService = new UserMySqlServiceImpl();
userService.getUser();
}
}
输出结果:这是Mysql的方法
由此可见,在我们之前的业务中,I用户的需求可能会影响我们原来的代码,我们需要根据用户的需求去修改原代码!如果程序代码量十分大,修改一次的成本代价十分昂贵!
我们使用一个Set接口实现.已经发生了革命性的变化!
private UserDao userDao;
// 利用set进行动态实现值的注入
public void setUserDao(UserDao userDao){
this.userDao = userDao;
}
- 之前,程序是主动创建对象!控制权在程序猿手上!
- 使用了set注入后,程序不再具有主动性,而是变成了被动的接受对象!
这种思想,从本质上解决了问题,我们程序猿不用再去管理对象的创建了。系统的耦合性大大降低,可以更加专注的在业务的实现上!这是IOC的原型!
IOC本质
控制反转loC(Inversion of Control),是一种设计思想,DI(依赖注入)是实现loC的一种方法,也有人认为DI只是loC的另一种说法。没有loC的程序中,我们使用面向对象编程,对象的创建与对象间的依赖关系完全硬编码在程序中,对象的创建由程序自己控制,控制反转后将对象的创建转移给第三方,个人认为所谓控制反转就是:获得依赖对象的方式反转了。
采用XML方式配置Bean的时候,Bean的定义信息是和实现分离的,而采用注解的方式可以把两者合为一体,Bean的定义信息直接以注解的形式定义在实现类中,从而达到了零配置的目的。
控制反转是一种通过描述((XML或注解)并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是loC容器,其实现方法是依赖注入(Dependency Injection,Dl)。
3、HelloSpring
导入Jar包
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.9</version>
</dependency>
编写代码
1、编写一个Hello实体类
package com.ryh.pojo;
public class Hello {
private String name;
public Hello() {
}
public Hello(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Hello{" +
"name='" + name + '\'' +
'}';
}
}
2、编写我们的spring文件 , 这里我们命名为beans.xml
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--使用Spring来创建对象,在Spring这些都称为Bean
类型 变量名 = new 类型();
Hello hello = new Hello();
id = 变量名;
class = new 的对象 全路径名
property 相当于给对象中的一个属性设置一个值
-->
<bean id="hello" class="com.ryh.pojo.Hello">
<property name="name" value="Spring" />
</bean>
</beans>
3、我们可以去进行测试了
实例化容器
提供给
ApplicationContext
构造函数的位置路径是资源字符串,这些资源字符串使容器可以从各种外部资源(例如本地文件系统,JavaCLASSPATH
等)加载配置元数据。ApplicationContext context = new ClassPathXmlApplicationContext("services.xml", "daos.xml");
import com.ryh.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
// 获取Spring的上下文对象
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
// 我们的对象都在Spring中管理了,我们直接使用,直接去里面取出来就可以了
Hello hello = (Hello) context.getBean("hello");
System.out.println(hello.toString());
}
}
思考
- Hello 对象是谁创建的 ? hello 对象是由Spring创建的
- Hello 对象的属性是怎么设置的 ? hello 对象的属性是由Spring容器设置的
这个过程就叫控制反转 :
控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的
反转 : 程序本身不创建对象 , 而变成被动的接收对象 .
依赖注入 : 就是利用set方法来进行注入的.
可以通过 注释掉此处的set方法,观察xml文件的变化 来理解 依赖注入。
IOC是一种编程思想,由主动的编程变成被动的接收 我们不需要再改动程序中的代码,只需要修改xml配置文件就可以实现。
ioc简单来说就是对象交给Spring来创建,管理,装配。
修改传统程序,新增一个xml文件
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="userDaoImpl" class="com.ryh.dao.UserDaoImpl" />
<bean id="userMySqlDaoImpl" class="com.ryh.dao.UserMySqlDaoImpl" />
<bean id="userServiceImpl" class="com.ryh.service.UserServiceImpl">
<!--
ref : 引用Spring容器中创建好的对象
value : 具体的值,基本数据类型
-->
<property name="userDao" ref="userDaoImpl" />
</bean>
</beans>
测试
package com.ryh;
import com.ryh.service.UserService;
import com.ryh.service.UserServiceImpl;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
// 获取ApplicationContext;拿到Spring的容器
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
// 想要什么,就get什么
UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("userServiceImpl");
userServiceImpl.getUser();
}
}
输出结果:这是传统的方法
想要更换用户需求的话,只需要修改xml配置中的ref
指向即可
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="userDaoImpl" class="com.ryh.dao.UserDaoImpl" />
<bean id="userMySqlDaoImpl" class="com.ryh.dao.UserMySqlDaoImpl" />
<bean id="userServiceImpl" class="com.ryh.service.UserServiceImpl">
<!--
ref : 引用Spring容器中创建好的对象
value : 具体的值,基本数据类型
-->
<property name="userDao" ref="userMySqlDaoImpl" />
</bean>
</beans>
4、IOC创建对象的方式
- 使用无参构造创建对象,默认
package com.ryh.pojo;
public class User {
private String name;
public User() {
System.out.println("这是user的无参构造");
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println(this.name);
}
}
创建配置文件
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id = "user" class="com.ryh.pojo.User">
<property name="name" value="renyuhua" />
</bean>
</beans>
测试
import com.ryh.pojo.User;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
User user = (User) context.getBean("user");
user.show();
}
}
输出结果:这是user的无参构造
- 使用有参构造创建
实体类
package com.ryh.pojo;
public class User {
private String name;
public User(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println(this.name);
}
}
配置文件
- 下标赋值
<!--1、下标赋值-->
<bean id = "user" class="com.ryh.pojo.User">
<constructor-arg index="0" value="hlx" />
</bean>
- 通过类型创建
<!--2、通过类型创建,不建议使用-->
<bean id = "user" class="com.ryh.pojo.User">
<constructor-arg type="java.lang.String" value="hlx" />
</bean>
- 通过参数名创建(常用)
<!--3、通过参数名创建-->
<bean id = "user" class="com.ryh.pojo.User">
<constructor-arg name="name" value="hlx" />
</bean>
结论:在配置文件加载的时候。其中管理的对象就已经初始化了
5、Spring配置
5.1、别名
<!--设置别名:在获取Bean的时候可以使用别名获取-->
<alias name="user" alias="u" />
5.2、Bean的配置
<!--
id : bean的唯一标识符,炮就是相当于我们学的对象名
class : bean对象所对应的全限定名:包名+类型
name : 也是别名,name可以同时取多个别名,并且分隔符很随意
-->
<bean id = "user" class="com.ryh.pojo.User" name="user2 user3,user4;user5">
<constructor-arg name="name" value="任宇华" />
</bean>
5.3、import
这个import,一般用于团队开发使用,他可以将多个配置文件,导入合并为一个
假设,现在项目中有多个人开发,这三个人复制不同的类开发,不同的类需要注册在不同的bean中,我们可以利用import将所有人的beans.xml合并为一个总的!
- applicationContext.xml
<beans .......>
<import resource="beans.xml"/>
<import resource="bean1.xml"/>
<import resource="bean2.xml"/>
</beans>
6、DI依赖注入
6.1、构造器注入
前面已经了解过 (4 IOC创建对象的方式 无参 有参)
6.2、Set方式注入
- 依赖注入
- 依赖:bean对象的创建依赖于容器
- 注入:bean对象中的所有属性,由容器来注入!
- 复杂类型 Address.java
package com.ryh.pojo;
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
- 真实测试对象 Student.java
package com.ryh.pojo;
import java.util.*;
public class Student {
private String name;
private Address address;
private String[] books;
private List<String> hobbys;
private Map<String,String> card;
private Set<String> games;
private String wife;
private Properties info;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public String[] getBooks() {
return books;
}
public void setBooks(String[] books) {
this.books = books;
}
public List<String> getHobbys() {
return hobbys;
}
public void setHobbys(List<String> hobbys) {
this.hobbys = hobbys;
}
public Map<String, String> getCard() {
return card;
}
public void setCard(Map<String, String> card) {
this.card = card;
}
public Set<String> getGames() {
return games;
}
public void setGames(Set<String> games) {
this.games = games;
}
public String getWife() {
return wife;
}
public void setWife(String wife) {
this.wife = wife;
}
public Properties getInfo() {
return info;
}
public void setInfo(Properties info) {
this.info = info;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", address=" + address +
", books=" + Arrays.toString(books) +
", hobbys=" + hobbys +
", card=" + card +
", games=" + games +
", wife='" + wife + '\'' +
", info=" + info +
'}';
}
}
- beans.xml
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="student" class="com.ryh.pojo.Student">
<!--第一种:普通值注入 使用value注入值-->
<property name="name" value="任宇华" />
</bean>
</beans>
- MyTest.java
import com.ryh.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student student = (Student) context.getBean("student");
System.out.println(student.getName());
}
}
完善注入信息
bean.xml
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="address" class="com.ryh.pojo.Address">
<property name="address" value="中国" />
</bean>
<bean id="student" class="com.ryh.pojo.Student">
<!--普通值注入-->
<property name="name" value="任宇华" />
<!--Bean注入 ref-->
<property name="address" ref="address" />
<!--数组-->
<property name="books">
<array>
<value>红楼梦</value>
<value>西游记</value>
<value>水浒传</value>
<value>三国演义</value>
</array>
</property>
<!--List-->
<property name="hobbys">
<list>
<value>听歌</value>
<value>敲代码</value>
<value>看电影</value>
</list>
</property>
<!--Map-->
<property name="card">
<map>
<entry key="身份证" value="1111111111" />
<entry key="银行卡" value="2222222222" />
</map>
</property>
<!--Set-->
<property name="games">
<set>
<value>LOL</value>
<value>COC</value>
<value>BOB</value>
</set>
</property>
<!--NOLL-->
<property name="wife">
<null />
</property>
<!--Properties-->
<property name="info">
<props>
<prop key="学号">20181666554</prop>
<prop key="性别">男</prop>
<prop key="名字">任宇华</prop>
</props>
</property>
</bean>
</beans>
测试类
import com.ryh.pojo.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student student = (Student) context.getBean("student");
System.out.println(student.toString());
/*
Student{
name='滕懿康',
address=Address{address='中国'},
books=[红楼梦, 西游记, 水浒传, 三国演义],
hobbys=[听歌, 敲代码, 看电影],
card={
身份证=1111111111,
银行卡=2222222222},
games=[LOL, COC, BOB],
wife='null',
info={
学号=20181666554,
性别=男,
名字=张三
}
}
*/
}
}
6.3、扩展方式注入
User.java
package com.ryh.pojo;
public class User {
private String name;
private int age;
public User() {
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
p命名空间和c命名空间
<?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:c="http://www.springframework.org/schema/c"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--p命名空间注入可以直接注入属性的值 : property-->
<bean id="user" class="com.ryh.pojo.User" p:name="任宇华" p:age="20" />
<!--c命名空间注入,通过构造器注入,即实体类必须有无参有参构造: construct-args-->
<bean id="user2" class="com.ryh.pojo.User" c:age="22" c:name="任宇华" />
</beans>
测试
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("userBeans.xml");
User user = (User) context.getBean("user");
User user2 = (User) context.getBean("user2");
System.out.println(user+user2);
}
注意点:p命名和c命名空间不能直接使用,需要导入xml约束!
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
6.4、bean的作用域
-
单例模式
<bean id="accountService" class="com.something.DefaultAccountService" scope="singleton"/>
测试
@Test
public void test(){
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("userBeans.xml");
User user = (User) context.getBean("user2");
User user2 = (User) context.getBean("user2");
System.out.println(user==user2); //true 单例模式为默认
}
默认就是单例模式
- 原型模式
<bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/>
测试
@Test
public void test(){
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("userBeans.xml");
User user = (User) context.getBean("user2");
User user2 = (User) context.getBean("user2");
System.out.println(user==user2); //false
}
原型模式每次从容器中get的时候都会产生一个新的对象
- 其余的request、session、application、这些只能在web开发中使用到
7、Bean的自动装配
自动装配是Spring满足bean依赖一种方式
Spring会在上下文中自动寻找,并自动给bean装配属性
在Spring中有三种装配的方式:
-
在xml中显示的配置
-
在java中显示配置
-
隐式的自动装配bean(重要)
7.1、测试
环境搭建:一个人有两个宠物
cat.java
package com.ryh.pojo;
public class Cat {
public void shout(){
System.out.println("miao~~~~");
}
}
dag.java
package com.ryh.pojo;
public class Dog {
public void shout(){
System.out.println("wang~~~~");
}
}
people.java
package com.ryh.pojo;
public class People {
private Cat cat;
private Dog dog;
private String name;
public Cat getCat() {
return cat;
}
public void setCat(Cat cat) {
this.cat = cat;
}
public Dog getDog() {
return dog;
}
public void setDog(Dog dog) {
this.dog = dog;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "People{" +
"cat=" + cat +
", dog=" + dog +
", name='" + name + '\'' +
'}';
}
}
beans.xml
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="dog" class="com.ryh.pojo.Dog" />
<bean id="cat" class="com.ryh.pojo.Cat" />
<bean id="people" class="com.ryh.pojo.People">
<property name="name" value="任宇华" />
<property name="cat" ref="cat" />
<property name="dog" ref="dog" />
</bean>
</beans>
MyTest.java
import com.ryh.pojo.People;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
People people = context.getBean("people",People.class);
people.getCat().shout();
people.getDog().shout();
}
}
7.2、ByName自动装配
<!--
byName:会自动在容器上下文中查找,和自己对象set方法后面的值对应的bean id !
-->
<bean id="people" class="com.ryh.pojo.People" autowire="byName">
<property name="name" value="任宇华" />
</bean>
7.3、ByType自动装配
<bean class="com.ryh.pojo.Dog" />
<bean class="com.ryh.pojo.Cat" />
<!--
byName:会自动在容器上下文中查找,和自己对象set方法后面的值对应的bean id !
byType:会自动在容器上下文中查找,和自己对象属性类型相同的bean !
-->
<bean id="people" class="com.ryh.pojo.People" autowire="byType">
<property name="name" value="任宇华" />
</bean>
小结:
- byName的时候,需要保证所有bean的id唯一,并且这个bean需要和自动注入的属性的set方法的值一致!
- byType的时候,需要保证所有bean的class唯一,并且这个bean需要和自动注入的属性的类型一致!
7.4、使用注解自动装配
jdk支持的注解,spring2.5就支持了
要使用注解须知:
1.导入约束 context
2.==配置注解的支持 context:annotation-config/
==重点!
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!-- 开启注解的支持,否则注解无效 -->
<context:annotation-config/>
</beans>
@Autowired注解
- **直接在属性上使用即可!**也可以在set方式上使用!
- 使用@Autowired 我们可以不用编写Set方法了,前提是你这个自动装配的属性在lOC(Spring)容器中存在,且符合名字byname!
@Nullable 字段标记了这个注解,说明这个字段可以为nu11
// 如果显式定义了Autowired的required属性为false,则说明这个对象可以为空,否则不允许为空
@Autowired(required = false)
private Cat cat;
@Autowired
private Dog dog;
注意:如果@Autowired自动装配的环境比较复杂,自动装配无法通过一个注解【@Autowired】完成的时候、我们可以使用
@Qualifier(value=“xxx”)
去配置@Autowired的使用,指定一个唯一的bean对象注入!
@Autowired
@Qualifier(value = "dog2")
private Dog dog;
<bean id="dog" class="com.ryh.pojo.Dog" />
<bean id="dog2" class="com.ryh.pojo.Dog" />
@Resource注解
@Resource
private Cat cat;
@Resource
private Dog dog;
@Resource和@Autowired区别
- 都是用来自动装配的,都可以放在属性字段上
- @Autowired通过byType的方式实现,而且必须要求这个对象存在!
- **@Resource默认通过byName的方式实现,如果找不到名字,则通过byType实现!**如果两个都找不到的情况下,就报错!
- 执行顺序不同
8、使用注解开发
在Spring4之后,要使用注解开发,必须要保证aop的包导入了
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.3.15</version>
</dependency>
使用注解需要导入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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<context:annotation-config/>
</beans>
- bean
package com.ryh.pojo;
import org.springframework.stereotype.Component;
//等价于 <bean id="user" class="com.ryh.pojo.User" />
//@Component组件
@Component
public class User {
public String name = "任宇华";
}
配置文件
<!--指定要扫描的包,这个包下的注解就会生效-->
<context:component-scan base-package="com.ryh.pojo" />
- 属性如何注入
public class User {
//相当于 <property name="name" value="任宇华" />
@Value("任宇华")
public String name;
}
相当于:
@Component
public class User {
//相当于 <property name="name" value="任宇华" />
public String name;
@Value("任宇华")
public void setName(String name) {
this.name = name;
}
}
- 衍生的注解
- @Component有几个衍生注解,我们在web开发中,会按照mvc三层架构分层!
@Component
public class User {
}
- dao【@Repository】
package com.ryh.dao;
import org.springframework.stereotype.Repository;
@Repository
public class UserDao {
}
- service【@Service】
package com.ryh.service;
import org.springframework.stereotype.Service;
@Service
public class UserService {
}
- controller【@Controller】
package com.ryh.controller;
import org.springframework.stereotype.Controller;
@Controller
public class UserController {
}
这四个注解的功能都是一样的,都是代表将某个类注册到Spring中,装配Bean
- 作用域(参考6.4 bean的作用域)
//相当于 <bean scope="prptotype">原型模式
@Scope("prototype")
public class User {
}
- 自动装配
@Resource和@Autowired
- 小结
-
xml与注解:
- xml更加万能,适用于任何场合!维护简单方便
- 注解不是自己类是用不了,维护相对复杂
-
xml与注解最佳实践
- xml用来管理bean
- 注解只完成属性的注入
- 我们在使用过程中,必须使注解生效,则必须要开启注解的支持,以及扫描包
<!--指定要扫描的包 -->
<context:component-scan base-package="com.ryh" />
<!--开启注解支持 -->
<context:annotation-config/>
9、使用Java的方式配置Spring
我们现在要完全不使用Spring的xml配置了,全权交给Java来做
JavaConfig 是Spring的一个子项目,在$pring 4之后,它成为了一个核心功能!
实体类
package com.ryh.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
// 这里这个注解的意思。就是说明这个类被Spring接管了,注附到了容器中
@Component
public class User {
private String name;
public String getName() {
return name;
}
@Value("滕懿康")
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
配置文件类
package com.ryh.config;
import com.ryh.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@Configuration
// 这个也会Spring容器托管,注入到容器中,因为他本来就是一个@Component
// @Configuration代表这是一个配置类,相当于之前的的beans.xmL
@ComponentScan("com.ryh.pojo") //扫描包
@Import(MyConfig2.class) //导入其他配置类
public class MyConfig {
// 注册一个bean,就相当于之前写的bean标签
// 这个方法的名字,就相当于bean的id属性
// 这个方法的返回值,就相当于bean标签中的class属性
@Bean
public User getUser(){
return new User(); // 返回要注入的bean的对象
}
}
配置类2
package com.ryh.config;
public class MyConfig2 {
}
测试类
import com.ryh.config.MyConfig;
import com.ryh.pojo.User;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class MyTest {
public static void main(String[] args) {
// 如果完全使用了配置类方式去做,只能通过AnnotationConfig上下文来获取容器,通过配置类的class对象加载!
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
User user = context.getBean("user", User.class);
System.out.println(user.getName());
}
}
这种纯java的配置方式,在SpringBoot中随处可见