Spring

已于 2022-07-07 16:18:28 修改
阅读量412 收藏
点赞数
分类专栏： idea maven 文章标签： spring maven
于 2022-07-06 10:38:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57363155/article/details/125633729
版权

1、Spring概述

 1.1 简介

  • Spring : 春天 --->给软件行业带来了春天
  • 2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。
  • 2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。
  • 很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。 Spring理念 : 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术

官网 :https://spring.io/

官方下载地址 :https://repo.spring.io/ui/native/libs-release-local/org/springframework/spring/

GitHub :https://github.com/spring-projects

1.2 优点

  • Spring是一个开源免费的框架 , 容器 .
  • Spring是一个轻量级的框架 , 非侵入式的 .
  • 控制反转 IoC , 面向切面 Aop
  • 对事物的支持 , 对框架的支持

一句话概括：Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。

1.3 组成

 Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器 定义了创建、配置和管理 bean 的方式 .

 组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模 块的功能如下：

  • 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory ，它 是工厂模式的实现。 BeanFactory 使用控制反转（IOC） 模式将应用程序的配置和依赖性规范 与实际的应用程序代码分开。
  • Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文 包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
  • Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖组件，就可以 将声明性事务管理集成到应用程序中。
  • Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不 同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异 常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次 结构。
  • Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包 括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结 构。
  • Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提 供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请 求以及将请求参数绑定到域对象的工作。
  • Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口， MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

1.4 拓展

Spring Boot与Spring Cloud

  • Spring Boot 是 Spring 的一套快速配置脚手架，可以基于Spring Boot 快速开发单个微服务;
  • Spring Cloud是基于Spring Boot实现的；
  • Spring Boot专注于快速、方便集成的单个微服务个体，Spring Cloud关注全局的服务治理框架；
  • Spring Boot使用了约束优于配置的理念，很多集成方案已经帮你选择好了，能不配置就不配置 , Spring Cloud很大的一部分是基于Spring Boot来实现，Spring Boot可以离开Spring Cloud独立使 用开发项目，但是Spring Cloud离不开Spring Boot，属于依赖的关系。
  • SpringBoot在SpringClound中起到了承上启下的作用，如果你要学习SpringCloud必须要学习 SpringBoot。

 2、IoC基础

新建一个空白的maven项目

2.1 分析实现

我们先用我们原来的方式写一段代码 .

1. 先写一个UserDao接口

public interface UserDao {
public void getUser();
}

2. 再去写Dao的实现类

public class UserDaoImpl implements UserDao {
@Override
public void getUser() {
System.out.println("获取用户数据");
}
}

3. 然后去写UserService的接口

public interface UserService {
public void getUser();
}

4. 最后写Service的实现类

public class UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoImpl();
@Override
public void getUser() {
userDao.getUser();
}
}

5. 测试一下

@Test
public void test(){
UserService service = new UserServiceImpl();
service.getUser();
}

这是我们原来的方式 , 开始大家也都是这么去写的对吧 . 那我们现在修改一下 . 把Userdao的实现类增加一个 .

public class UserDaoMySqlImpl implements UserDao {
@Override
public void getUser() {
System.out.println("MySql获取用户数据");
}
}

紧接着我们要去使用MySql的话 , 我们就需要去service实现类里面修改对应的实现 .

public class UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoMySqlImpl();
@Override
public void getUser() {
userDao.getUser();
}
}

在假设, 我们再增加一个Userdao的实现类 .

public class UserDaoOracleImpl implements UserDao {
@Override
public void getUser() {
System.out.println("Oracle获取用户数据");
}
}

那么我们要使用Oracle , 又需要去service实现类里面修改对应的实现 . 假设我们的这种需求非常大 , 这种 方式就根本不适用了, 甚至反人类对吧 , 每次变动 , 都需要修改大量代码 . 这种设计的耦合性太高了, 牵一 发而动全身 .

那我们如何去解决呢 ?

我们可以在需要用到他的地方 , 不去实现它 , 而是留出一个接口 , 利用set , 我们去代码里修改下 .

public class UserServiceImpl implements UserService {
private UserDao userDao;
// 利用set实现
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@Override
public void getUser() {
userDao.getUser();
}
}

现在去我们的测试类里 , 进行测试 ;

@Test
public void test(){
UserServiceImpl service = new UserServiceImpl();
service.setUserDao( new UserDaoMySqlImpl() );
service.getUser();
//那我们现在又想用Oracle去实现呢
service.setUserDao( new UserDaoOracleImpl() );
service.getUser();
}

大家发现了区别没有 ? 可能很多人说没啥区别 . 但是同学们 , 他们已经发生了根本性的变化 , 很多地方都 不一样了 . 仔细去思考一下 , 以前所有东西都是由程序去进行控制创建 , 而现在是由我们自行控制创建对 象 , 把主动权交给了调用者 . 程序不用去管怎么创建,怎么实现了 . 它只负责提供一个接口 .

这种思想 , 从本质上解决了问题 , 我们程序员不再去管理对象的创建了 , 更多的去关注业务的实现 . 耦合 性大大降低 . 这也就是IOC的原型 !

2.2 IOC本质

控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认 为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系 完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为 所谓控制反转就是：获得依赖对象的方式反转了。

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解， 新版本的Spring也可以零配置实现IoC。 

Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用 时再从Ioc容器中取出需要的对象。

 采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为 一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现 控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

3、HelloSpring

3.1、导入Jar包

注 : spring 需要导入commons-logging进行日志记录 . 我们利用maven , 他会自动下载对应的依赖项 .

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.1.10.RELEASE</version>
</dependency>

3.2、编写代码

1. 编写一个Hello实体类

public class Hello {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("Hello,"+ 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就是java对象 , 由Spring创建和管理-->

   <bean id="hello" class="com.zhou.pojo.Hello">
       <property name="name" value="mm"/>
   </bean>
</beans>

3. 我们可以去进行测试了 .

@Test
public void test(){
//解析beans.xml文件 , 生成管理相应的Bean对象
ApplicationContext context = new
ClassPathXmlApplicationContext("beans.xml");
//getBean : 参数即为spring配置文件中bean的id .
Hello hello = (Hello) context.getBean("hello");
hello.show();
}

3.3、思考

  • Hello 对象是谁创建的 ? 【 hello 对象是由Spring创建的 】
  • Hello 对象的属性是怎么设置的 ? 【hello 对象的属性是由Spring容器设置的 】

这个过程就叫控制反转 :

  • 控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是 由Spring来创建的
  • 反转 : 程序本身不创建对象 , 而变成被动的接收对象 .

依赖注入 : 就是利用set方法来进行注入的.

IOC是一种编程思想，由主动的编程变成被动的接收

可以通过newClassPathXmlApplicationContext去浏览一下底层源码 .

3.4、修改案例一

我们在案例一中， 新增一个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
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="MysqlImpl" class="com.zhou.dao.impl.UserDaoMySqlImpl"/>
<bean id="OracleImpl" class="com.zhou.dao.impl.UserDaoOracleImpl"/>
<bean id="ServiceImpl" class="com.zhou.service.impl.UserServiceImpl">
<!--注意: 这里的name并不是属性 , 而是set方法后面的那部分 , 首字母小写-->
<!--引用另外一个bean , 不是用value 而是用 ref-->
<property name="userDao" ref="OracleImpl"/>
</bean>
</beans>

测试！

@Test
public void test2(){
ApplicationContext context = new
ClassPathXmlApplicationContext("beans.xml");
UserServiceImpl serviceImpl = (UserServiceImpl)
context.getBean("ServiceImpl");
serviceImpl.getUser();
}

OK , 到了现在 , 我们彻底不用再程序中去改动了 , 要实现不同的操作 , 只需要在xml配置文件中进行修改 , 所谓的IoC,一句话搞定 : 对象由Spring 来创建 , 管理 , 装配 !

4、IOC创建对象方式

4.1.通过无参构造方法来创建

1. User.java

public class User {
private String name;
public User() {
System.out.println("user无参构造方法");
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("name="+ name );
}
}

2. 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
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="user" class="com.zhou.pojo.User">
<property name="name" value="zhougang"/>
</bean>
</beans>

3. 测试类

@Test
public void test(){
ApplicationContext context = new
ClassPathXmlApplicationContext("beans.xml");
//在执行getBean的时候, user已经创建好了 , 通过无参构造
User user = (User) context.getBean("user");
//调用对象的方法 .
user.show();
}

结果可以发现，在调用show方法之前，User对象已经通过无参构造初始化了！

4.2.通过有参构造方法来创建

1. UserT . java

public class UserT {
private String name;
public UserT(String name) {
this.name = name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("name="+ name );
}
}

2. beans.xml 有三种方式编写

<!-- 第一种根据index参数下标设置 -->
<bean id="userT" class="com.zhou.pojo.UserT">
<!-- index指构造方法 , 下标从0开始 -->
<constructor-arg index="0" value="zhougang2"/>
</bean>
<!-- 第二种根据参数名字设置 -->
<bean id="userT" class="com.zhou.pojo.UserT">
<!-- name指参数名 -->
<constructor-arg name="name" value="zhougang2"/>
</bean>
<!-- 第三种根据参数类型设置 -->
<bean id="userT" class="com.zhou.pojo.UserT">
<constructor-arg type="java.lang.String" value="zhougang2"/>
</bean>

3. 测试

@Test
public void testT(){
ApplicationContext context = new
ClassPathXmlApplicationContext("beans.xml");
UserT user = (UserT) context.getBean("userT");
user.show();
}

结论：在配置文件加载的时候。其中管理的对象都已经初始化了！

5、Spring配置

5.1. 别名

alias 设置别名 , 为bean设置别名 , 可以设置多个别名

<!--设置别名：在获取Bean的时候可以使用别名获取-->
<alias name="userT" alias="userNew"/>

5.2. Bean的配置

<!--bean就是java对象,由Spring创建和管理-->
<!--
id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
如果配置id,又配置了name,那么name是别名
name可以设置多个别名,可以用逗号,分号,空格隔开
如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;
class是bean的全限定名=包名+类名
-->
<bean id="hello" name="hello2 h2,h3;h4" class="com.zhou.pojo.Hello">
<property name="name" value="Spring"/>
</bean>

5.3. import

团队的合作通过import来实现 .

<import resource="{path}/beans.xml"/>

6、依赖注入（DI）

  • 依赖注入（Dependency Injection,DI）。
  • 依赖 : 指Bean对象的创建依赖于容器 . Bean对象的依赖资源 .
  • 注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配 .

6.1 构造器注入

我们在之前的案例4已经详细讲过了

6.2 set注入 (重点)

要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is .

测试pojo类 :

Address.java

public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}

Student.java

package com.zhou.pojo;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
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 void setName(String name) {
this.name = name;
}
public void setAddress(Address address) {
this.address = address;
}
public void setBooks(String[] books) {
this.books = books;
}
public void setHobbys(List<String> hobbys) {
this.hobbys = hobbys;
}
public void setCard(Map<String, String> card) {
this.card = card;
}
public void setGames(Set<String> games) {
this.games = games;
}
public void setWife(String wife) {
this.wife = wife;
}
public void setInfo(Properties info) {
this.info = info;
}
public void show(){
System.out.println("name="+ name
+ ",address="+ address.getAddress()
+ ",books="
);
for (String book:books){
System.out.print("<<"+book+">>\t");
}
System.out.println("\n爱好:"+hobbys);
System.out.println("card:"+card);
System.out.println("games:"+games);
System.out.println("wife:"+wife);
System.out.println("info:"+info);
}
}

1、常量注入

<bean id="student" class="com.zhou.pojo.Student">
<property name="name" value="小明"/>
</bean>

测试：

@Test
public void test01(){
ApplicationContext context = new
ClassPathXmlApplicationContext("applicationContext.xml");
Student student = (Student) context.getBean("student");
System.out.println(student.getName());
}

2、Bean注入

注意点：这里的值是一个引用，ref

<bean id="addr" class="com.zhou.pojo.Address">
<property name="address" value="重庆"/>
</bean>
<bean id="student" class="com.zhou.pojo.Student">
<property name="name" value="小明"/>
<property name="address" ref="addr"/>
</bean>

3、数组注入

<bean id="student" class="com.zhou.pojo.Student">
<property name="name" value="小明"/>
<property name="address" ref="addr"/>
<property name="books">
<array>
<value>西游记</value>
<value>红楼梦</value>
<value>水浒传</value>
</array>
</property>
</bean>

4、List注入

<property name="hobbys">
<list>
<value>听歌</value>
<value>看电影</value>
<value>爬山</value>
</list>
</property>

5、Map注入

<property name="card">
<map>
<entry key="中国邮政" value="456456456465456"/>
<entry key="建设" value="1456682255511"/>
</map>
</property>

6、set注入

<property name="games">
<set>
<value>LOL</value>
<value>BOB</value>
<value>COC</value>
</set>
</property>

7、Null注入

<property name="wife"><null/></property>

8、Properties注入

<property name="info">
<props>
<prop key="学号">20190604</prop>
<prop key="性别">男</prop>
<prop key="姓名">小明</prop>
</props>
</property>

测试结果：

6.3 拓展注入实现 

User.java ： 【注意：这里没有有参构造器！】

public class User {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}

1、P命名空间注入 : 需要在头文件中假如约束文件

导入约束 : xmlns:p="http://www.springframework.org/schema/p"
<!--P(属性: properties)命名空间 , 属性依然要设置set方法-->
<bean id="user" class="com.zhou.pojo.User" p:name="周钢" p:age="18"/>

2、c 命名空间注入 : 需要在头文件中假如约束文件

导入约束 : xmlns:c="http://www.springframework.org/schema/c"
<!--C(构造: Constructor)命名空间 , 属性依然要设置set方法-->
<bean id="user" class="com.zhou.pojo.User" c:name="周钢" c:age="18"/>

发现问题：爆红了，刚才我们没有写有参构造！

解决：把有参构造器加上，这里也能知道，c 就是所谓的构造器注入！

测试代码：

@Test
public void test02(){
ApplicationContext context = new
ClassPathXmlApplicationContext("applicationContext.xml");
User user = (User) context.getBean("user");
System.out.println(user);
}

6.4 Bean的作用域

在Spring中，那些组成应用程序的主体及由Spring IoC容器所管理的对象，被称之为bean。简单地讲， bean就是由IoC容器初始化、装配及管理的对象 .

几种作用域中，request、session作用域仅在基于web的应用中使用（不必关心你所采用的是什么web 应用框架），只能用在基于web的Spring ApplicationContext环境。

6.4.1 Singleton 

当一个bean的作用域为Singleton，那么Spring IoC容器中只会存在一个共享的bean实例，并且所有对 bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。Singleton是单例类型，就是 在创建起容器时就同时自动创建了一个bean的对象，不管你是否使用，他都存在了，每次获取到的对象 都是同一个对象。注意，Singleton作用域是Spring中的缺省作用域。要在XML中将bean定义成 singleton，可以这样配置：

<bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">

测试：

@Test
public void test03(){
ApplicationContext context = new
ClassPathXmlApplicationContext("applicationContext.xml");
User user = (User) context.getBean("user");
User user2 = (User) context.getBean("user");
System.out.println(user==user2);
}

6.4.2 Prototype

当一个bean的作用域为Prototype，表示一个bean定义对应多个对象实例。Prototype作用域的bean会 导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法） 时都会创建一个新的bean实例。Prototype是原型类型，它在我们创建容器的时候并没有实例化，而是 当我们获取bean的时候才会去创建一个对象，而且我们每次获取到的对象都不是同一个对象。根据经 验，对有状态的bean应该使用prototype作用域，而对无状态的bean则应该使用singleton作用域。在 XML中将bean定义成prototype，可以这样配置：

<bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>
或者
<bean id="account" class="com.foo.DefaultAccount" singleton="false"/>

6.4.3 Request

当一个bean的作用域为Request，表示在一次HTTP请求中，一个bean定义对应一个实例；即每个HTTP 请求都会有各自的bean实例，它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

<bean id="loginAction" class=cn.csdn.LoginAction" scope="request"/>

针对每次HTTP请求，Spring容器会根据loginAction bean的定义创建一个全新的LoginAction bean实 例，且该loginAction bean实例仅在当前HTTP request内有效，因此可以根据需要放心的更改所建实例 的内部状态，而其他请求中根据loginAction bean定义创建的实例，将不会看到这些特定于某个请求的 状态变化。当处理请求结束，request作用域的bean实例将被销毁。

6.4.4 Session

当一个bean的作用域为Session，表示在一个HTTP Session中，一个bean定义对应一个实例。该作用域 仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

<bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>

针对某个HTTP Session，Spring容器会根据userPreferences bean定义创建一个全新的 userPreferences bean实例，且该userPreferences bean仅在当前HTTP Session内有效。与request作 用域一样，可以根据需要放心的更改所创建实例的内部状态，而别的HTTP Session中根据 userPreferences创建的实例，将不会看到这些特定于某个HTTP Session的状态变化。当HTTP Session 最终被废弃的时候，在该HTTP Session作用域内的bean也会被废弃掉。

7、Bean的自动装配

  • 自动装配是使用spring满足bean依赖的一种方法
  • spring会在应用上下文中为某个bean寻找其依赖的bean。

Spring中bean有三种装配机制，分别是：

1. 在xml中显式配置；

2. 在java中显式配置；

3. 隐式的bean发现机制和自动装配。

这里我们主要讲第三种：自动化的装配bean。

Spring的自动装配需要从两个角度来实现，或者说是两个操作：

1. 组件扫描(component scanning)：spring会自动发现应用上下文中所创建的bean；

2. 自动装配(autowiring)：spring自动满足bean之间的依赖，也就是我们说的IoC/DI；

组件扫描和自动装配组合发挥巨大威力，使的显示的配置降低到最少。

推荐不使用自动装配xml配置 , 而使用注解 .

7.1、测试环境搭建

1. 新建一个项目

2. 新建两个实体类，Cat Dog 都有一个叫的方法

public class Cat {
public void shout() {
System.out.println("miao~");
}
}
public class Dog {
public void shout() {
System.out.println("wang~");
}
}

3. 新建一个用户类 User

public class User {
private Cat cat;
private Dog dog;
private String str;
}

4. 编写Spring配置文件

<?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="dog" class="com.zhou.pojo.Dog"/>
<bean id="cat" class="com.zhou.pojo.Cat"/>
<bean id="user" class="com.zhou.pojo.User">
<property name="cat" ref="cat"/>
<property name="dog" ref="dog"/>
<property name="str" value="周钢"/>
</bean>
</beans>

5. 测试

public class MyTest {
@Test
public void testMethodAutowire() {
ApplicationContext context = new
ClassPathXmlApplicationContext("beans.xml");
User user = (User) context.getBean("user");
user.getCat().shout();
user.getDog().shout();
}
}

结果正常输出，环境OK

7.2、byName

autowire byName (按名称自动装配)

由于在手动配置xml过程中，常常发生字母缺漏和大小写等错误，而无法对其进行检查，使得开发效率 降低。

采用自动装配将避免这些错误，并且使配置简单化。

测试：

1. 修改bean配置，增加一个属性 autowire="byName"

<bean id="user" class="com.zhou.pojo.User" autowire="byName">
<property name="str" value="zhougang"/>
</bean>

2. 再次测试，结果依旧成功输出！

3. 我们将 cat 的bean id修改为 catXXX

4. 再次测试， 执行时报空指针java.lang.NullPointerException。因为按byName规则找不对应set方 法，真正的setCat就没执行，对象就没有初始化，所以调用时就会报空指针错误。

小结：

当一个bean节点带有 autowire byName的属性时。

1. 将查找其类中所有的set方法名，例如setCat，获得将set去掉并且首字母小写的字符串，即cat。 2. 去spring容器中寻找是否有此字符串名称id的对象。

3. 如果有，就取出注入；如果没有，就报空指针异常。

7.3、byType

autowire byType (按类型自动装配)

使用autowire byType首先需要保证：同一类型的对象，在spring容器中唯一。如果不唯一，会报不唯一 的异常。

NoUniqueBeanDefinitionException

测试：

1. 将user的bean配置修改一下 ： autowire="byType"

2. 测试，正常输出

3. 在注册一个cat 的bean对象！

<bean id="dog" class="com.zhou.pojo.Dog"/>
<bean id="cat" class="com.zhou.pojo.Cat"/>
<bean id="cat2" class="com.zhou.pojo.Cat"/>
<bean id="user" class="com.zhou.pojo.User" autowire="byType">
<property name="str" value="周钢"/>
</bean>

4. 测试，报错：NoUniqueBeanDefinitionException

5. 删掉cat2，将cat的bean名称改掉！测试！因为是按类型装配，所以并不会报异常，也不影响最后 的结果。甚至将id属性去掉，也不影响结果。

这就是按照类型自动装配！

7.4 使用注解

jdk1.5开始支持注解，spring2.5开始全面支持注解。

准备工作： 利用注解的方式注入属性。

1. 在spring配置文件中引入context文件头

xmlns:context="http://www.springframework.org/schema/context"
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd

2. 开启属性注解支持！

<context:annotation-config/>

7.4.1、@Autowired

  • @Autowired是按类型自动转配的，不支持id匹配。
  • 需要导入 spring-aop的包！

测试：

1. 将User类中的set方法去掉，使用@Autowired注解

public class User {
@Autowired
private Cat cat;
@Autowired
private Dog dog;
private String str;
public Cat getCat() {
return cat;
}
public Dog getDog() {
return dog;
}
public String getStr() {
return str;
}
}

2. 此时配置文件内容

<context:annotation-config/>
<bean id="dog" class="com.zhou.pojo.Dog"/>
<bean id="cat" class="com.zhou.pojo.Cat"/>
<bean id="user" class="com.zhou.pojo.User"/>

3. 测试，成功输出结果！

【科普时间】

@NonNull可以是参数为空不报错

 public Pent(@NonNull String name) {//当有参构造里面的参数name为空时不会报错，相当于无参构造
        this.name = name;
    }

@Autowired(required=false) 说明： false，对象可以为null；true，对象必须存对象，不能为null。

//如果允许对象为null，设置required = false,默认为true
@Autowired(required = false)
private Cat cat;

7.4.2、@Qualifier

  • @Autowired是根据类型自动装配的，加上@Qualifier则可以根据byName的方式自动装配
  • @Qualifier不能单独使用。

测试实验步骤：

1. 配置文件修改内容，保证类型存在对象。且名字不为类的默认名字！

<bean id="dog1" class="com.zhou.pojo.Dog"/>
<bean id="dog2" class="com.zhou.pojo.Dog"/>
<bean id="cat1" class="com.zhou.pojo.Cat"/>
<bean id="cat2" class="com.zhou.pojo.Cat"/>

2. 没有加Qualifier测试，直接报错

3. 在属性上添加Qualifier注解

@Autowired
@Qualifier(value = "cat2")
private Cat cat;
@Autowired
@Qualifier(value = "dog2")
private Dog dog;

4. 测试，成功输出！

7.4.3、@Resource

  • @Resource如有指定的name属性，先按该属性进行byName方式查找装配；
  • 其次再进行默认的byName方式进行装配；
  • 如果以上都不成功，则按byType的方式自动装配。
  • 都不成功，则报异常。

实体类：

public class User {
//如果允许对象为null，设置required = false,默认为true
@Resource(name = "cat2")
private Cat cat;
@Resource
private Dog dog;
private String str;
}

beans.xml

<bean id="dog" class="com.zhou.pojo.Dog"/>
<bean id="cat1" class="com.zhou.pojo.Cat"/>
<bean id="cat2" class="com.zhou.pojo.Cat"/>
<bean id="user" class="com.zhou.pojo.User"/>

测试：结果OK

配置文件2：beans.xml ， 删掉cat2

<bean id="dog" class="com.zhou.pojo.Dog"/>
<bean id="cat1" class="com.zhou.pojo.Cat"/>

实体类上只保留注解

@Resource
private Cat cat;
@Resource
private Dog dog;

结果：OK

结论：先进行byName查找，失败；再进行byType查找，成功。

7.5、小结

@Autowired与@Resource异同：

1. @Autowired与@Resource都可以用来装配bean。都可以写在字段上，或写在setter方法上。

2. @Autowired默认按类型装配（属于spring规范），默认情况下必须要求依赖对象必须存在，如果 要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我 们想使用名称装配可以结合@Qualifier注解进行使用

3. @Resource（属于J2EE复返），默认按照名称进行装配，名称可以通过name属性进行指定。如果 没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在 setter方法上默认取属性名进行装配。 当找不到与名称匹配的bean时才按照类型进行装配。但是 需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。

它们的作用相同都是用注解方式注入对象，但执行顺序不同。@Autowired先byType，@Resource先 byName。

8、使用注解开发

8.1、说明

在spring4之后，想要使用注解形式，必须得要引入aop的包

在配置文件当中，还得要引入一个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>

 8.2、Bean的实现

我们之前都是使用 bean 的标签进行bean注入，但是实际开发中，我们一般都会使用注解！

1. 配置扫描哪些包下的注解

<!--指定注解扫描包-->
<context:component-scan base-package="com.zhou.pojo"/>

2. 在指定包下编写类，增加注解

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
public String name = "周钢";
}

3. 测试

@Test
public void test(){
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
User user = (User) applicationContext.getBean("user");
System.out.println(user.name);
}

8.3、属性注入

使用注解注入属性

1. 可以不用提供set方法，直接在直接名上添加@value("值")

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
@Value("周钢")
// 相当于配置文件中 <property name="name" value="周钢"/>
public String name;
}

2. 如果提供了set方法，在set方法上添加@value("值");

@Component("user")
public class User {
public String name;
@Value("周钢")
public void setName(String name) {
this.name = name;
}
}

8.4、衍生注解

我们这些注解，就是替代了在配置文件当中配置步骤而已！更加的方便快捷！

@Component三个衍生注解

为了更好的进行分层，Spring可以使用其它三个注解，功能一样，目前使用哪一个功能都一样。

  • @Controller：web层
  • @Service：service层
  • @Repository：dao层

写上这些注解，就相当于将这个类交给Spring管理装配了！

8.5、自动装配注解

在Bean的自动装配已经讲过了，可以回顾！

8.6、作用域

@scope

  • singleton：默认的，Spring会采用单例模式创建这个对象。关闭工厂 ，所有的对象都会销毁。
  • prototype：多例模式。关闭工厂 ，所有的对象不会销毁。内部的垃圾回收机制会回收
@Controller("user")
@Scope("prototype")
public class User {
@Value("周钢")
public String name;
}

8.7、小结

XML与注解比较

  • XML可以适用任何场景 ，结构清晰，维护方便
  • 注解不是自己提供的类使用不了，开发简单方便

xml与注解整合开发 ：推荐最佳实践

  • xml管理Bean
  • 注解完成属性注入
  • 使用过程中， 可以不用扫描，扫描是为了类上的注解
<context:annotation-config/>

作用：

  • 进行注解驱动注册，从而使注解生效
  • 用于激活那些已经在spring容器里注册过的bean上面的注解，也就是显示的向Spring注册
  • 如果不扫描包，就需要手动配置bean
  • 如果不加注解驱动，则注入的值为null！

8.8、基于Java类进行配置

JavaConfig 原来是 Spring 的一个子项目，它通过 Java 类的方式提供 Bean 的定义信息，在 Spring4 的 版本， JavaConfig 已正式成为 Spring4 的核心功能 。

测试：

1. 编写一个实体类，Dog

@Component //将这个类标注为Spring的一个组件，放到容器中！
public class Dog {
public String name = "dog";
}

2. 新建一个config配置包，编写一个MyConfig配置类

@Configuration //代表这是一个配置类
public class MyConfig {
@Bean //通过方法注册一个bean，这里的返回值就Bean的类型，方法名就是bean的id！
public Dog dog(){
return new Dog();
}
}

3. 测试

@Test
public void test2(){
ApplicationContext applicationContext =
new AnnotationConfigApplicationContext(MyConfig.class);
Dog dog = (Dog) applicationContext.getBean("dog");
System.out.println(dog.name);
}

4. 成功输出结果！

导入其他配置如何做呢？

1. 我们再编写一个配置类！

@Configuration //代表这是一个配置类
public class MyConfig2 {
}

2. 在之前的配置类中我们来选择导入这个配置类

@Configuration
@ComponentScan("com.zhou")//扫包
@Import(MyConfig2.class) //导入合并其他配置类，类似于配置文件中的 inculde 标签
public class MyConfig {
@Bean
public Dog dog(){
return new Dog();
}
}

关于这种Java类的配置方式，我们在之后的SpringBoot 和 SpringCloud中还会大量看到，我们需要知道 这些注解的作用即可！

9、代理模式

狂徒-周钢
关注
专栏目录
@Service指定参数与不指定参数的细节问题
weixin_43351375的博客
09-20 4923
@Service指定参数与不指定参数的细节问题 原理：@Service(“userService”) , 它里边的参数就是xml文件中的bean id=userService，如果不指定，相当于 bean id=com.mooc.service.impl.UserServiceImpl 一般情况我们采用@Service注解的时候，不用这样@Service(“userService”)指定的， ...
Spring注解之Service详解
juggle_gap_horse的博客
02-11 2万+
使用Service注解的服务类为其他组件提供了一种复用业务逻辑的方法，能够减少重复代码的编写，提高代码的可维护性。常常与控制器组件和逻辑层的请求处理组件搭配使用：在控制器组件中注入服务类实例，然后使用该实例调用服务类的业务逻辑，将结果返回给请求处理组件。
Spring5框架-IOC容器
徐大大的博客
01-15 280
Spring5框架中IOC的 全面讲解，从底层原理到解析代码实现等
Spring框架入门学习笔记
qq_55737371的博客
05-01 940
Spring概述 1、Spring 是轻量级的开源的JavaEE框架 2、Spring可以解决企业应用开发的复杂性。 特点： (1) 方便解耦，简化开发。 (2) Aop编程支持。(Aop:不修改源代码的情况下进行功能增强) (3)方便程序测试 (4)方便和其他框架进行整合+ (5) 方便进行事务操作。 (6)降低API开发难度。 ...
Spring Boot常用注解（一） - 声明Bean的注解
热门推荐
李平安
01-24 4万+
1.概述 Spring Boot简化了Spring应用的开发，不需要繁琐的XML配置就能开发。 那Spring Boot是怎么实现自动配置的呢？ 这就要用到Spring Boot中提供的许多注解： Spring提供XML配置、注解配置或Java配置来实现Bean的创建和注入 Spring IoC(ApplicationContext)容器负责进行扫描Bean，进行Bean的初始化、配置和
Spring中文文档下载
09-27
Spring中文文档
spring6pdf详细讲解
09-18
spring6pdf详细讲解
spring jar包
08-05
spring-aop-3.2.2.RELEASE.jar spring-beans-3.2.2.RELEASE.jar spring-context-3.2.2.RELEASE.jar spring-context-support-3.2.2.RELEASE.jar spring-core-3.2.2.RELEASE.jar spring-data-commons-1.5.0.RELEASE....
spring源码
10-16
springmvc的源码，采用典型的三层架构进行开发，最简单的增删改查，登陆、修改密码等
SpringBlade开发手册基础版
05-23
SpringBlade开发手册基础版
Spring篇
weixin_43297789的博客
05-22 332
AOP的理解(what why how)？ 目录AOP的理解(what why how)？一：什么是AOP1、什么是spring2、spring优势3、什么是AOP。二、代码实现1、实现转账案列三、AOP 详解 一：什么是AOP 1、什么是spring    Spring是分层的 Java SE/EE应用 full-stack(全栈式) 轻量级开源框架。提供了表现层 SpringMVC和持久层 Spring JDBC Template以及 业务层 事务管理等众多的企业级应用技术，还能整合开源世界众多著名的
spring中`@Service(value=“XXX“)`中XXX的作用
qq_41845823的博客
02-11 7633
@Service的作用     spring中有很多注解帮助我们开发，@Repository、@Service 、@Controller 和@Component注解在类上面即可以使spring自动向Bean容器中创建该类的Bean，而在我们需要用到该Bean来创建对象时，在变量声明上方添加@AutoWired或者@Qualifier即可。 @Service(value="XXX")中的XXX的作用     @service注解工作原理：在service层类上面添加@Service注解，会自动创建Bean，B
底层解惑-spring的@service的原理及其一接口多实现的解决方案
特立独行的猿
05-19 5778
spring  @service注解的接口实现类，如果是单一实现类，直接在controller用@Resource注入就可以了 如果是多实现类，还这样做的话，就会报错（不止一个实例对象），于是可以如下做法：      1、在需要注入的地方使用如下方式引入：         @Autowired         @Qualifier("timeFilter")         Fi
Spring注解@Component、@Repository、@Service、@Controller区别
weixin_33940102的博客
04-03 6463
https://blog.csdn.net/xiao190128/article/details/54890759/   service  是有用的相当于 xml配置中得bean  id = service  也可以不指定 不指定相当于 bean id =  com. service.service 就是这个类的全限定名,表示给当前类命名一个别名，方便注入到其他需要用到的类中；不加的话，默认别名就...
Spring5：@Autowired注解、@Resource注解和@Service注解
一名努力的大学生，希望可以帮到更多人
01-07 1690
Spring5：@Autowired注解、@Resource注解和@Service注解
每天一个注解之@Service
qq_43406318的博客
08-11 2983
在Spring中，@Service是一种用于标记类的注解，它是一种特殊的组件扫描注解，通常用于表示一个服务类。是Spring Framework中的注解。
【Spring项目中的Service理解】
居然天上楼的博客
11-29 1591
在项目中，关于Service的开发，通常是先定义接口，再定义类实现此接口，接口名通常使用“数据类型Service”这样格式的名称，而实现类通常是在接口名的基础上再添加。，本次的参数应该包含：相册名称、相册简介、相册的排序序号，可以将这3个数据封装到自定义的DTO类中，并使用DTO类型作为参数。，并且，在后续的编程中，当需要执行某些判断时，应该优先根据“抛出异常”或“终止当前方法的执行”来设计。通常，建议自定义异常，并且，当视为失败时，抛出此自定义异常的对象！中添加相册时，如果相册名称被使用，则抛出。
spring动态修改service类的属性
qq_39517116的博客
09-08 485
然后通过Http长轮询不断的去获取服务端的配置信息，一旦配置发生变化，Apollo会根据变化的配置的Key找到对应的Bean，然后修改Bean的属性，从而实现了配置动态生效的特性。中的方法解决了问题，大致就是在spring bean属性注入后 实例化前拿到所有@value注解的属性（这个阶段获取到的属性都是原来自己写的），存入到自己的定义map中，然后修改的时候从自己定义的map中找到，然后反射赋值。使用正常反射拿到service，拿到的是cglib proxy代理后的，找不到filed，没办法处理。
Spring的@Service注解的用法
奋斗鱼
07-29 7230
首先，在applicationContext.xml文件中加一行： <context:component-scan base-package="com.my.services"/> 加上这一行以后，将自动扫描路径下面的包，如果一个类带了@Service注解，将自动注册到Spring容器，不需要再在applicationContext.xml文件定义bean了，类似的还包括@C...
spring saml
最新发布
12-08
Spring Security SAML是Spring Security的一个扩展，它提供了对基于SAML 1.1，2.0和WS-Federation的单点登录（SSO）的支持。它允许您将SAML身份验证和授权集成到Spring Security中，以便您可以使用Spring Security的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值