[Java知识库]尚硅谷Spring框架学习笔记

Spring框架

1. 官网下载地址：
2. Spring Framework 中文文档：
3. 本文是在看了b站的尚硅谷Spring5框架教程（idea版）
   总结出来的笔记以及见解

课程内容介绍：

1. Spring框架概述

2. IOC容器

3. Aop

4. JdbcTemplate

5. 事务管理

6. Spring5新特性

Spring框架概述：

1. Spring是轻量级的开源JaveEE框架

2. Sprig可以解决企业应用开发的复杂性

3. Spring有两个核心部分：IOC和Aop

（1）IOC：控制反转，把创建对象的过程交给Spring进行管理

（2）Aop：面向切面，不修改源代码进行功能增强

4. Spring特点

（1）方便解耦，简化开放

（2）Aop编程支持

（3）方便程序测试

（4）方便和其他框架进行整合

（5）方便进行事务操作

（6）降低API开发难度

*下面部分介绍来源于百度

Spring：
Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。
Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。
    轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。   
    控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。
    面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。
    容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。
    框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。
所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

Ioc容器

（1）IOC底层原理

（2）IOC接口（BeanFactory）

（3）IOC操作Bean管理

1. 什么是IOC

（1）控制反转，把对象的创建和对象之间的调用，交给Spring进行管理

? 对象A依赖于对象B,当对象 A需要用到对象B的时候，IOC容器就会立即创建一个对象B送给对象A。IOC容器就是一个对象制造工厂， 你需要什么，它会给你送去，你直接使用就行了，而再也不用去关心你所用的东西是如何制成的，也不用关心最后是怎么被销毁的，这一切全部由IOC容器包办。
在传统的实现中，由程序内部代码来控制组件之间的关系。我们经常使用new关键字来实现两个组件之间关系的组合，这种实现方式会造成组件之间耦合。IOC很好地解决了该问题，它将实现组件间关系从程序内部提到外部容器，也就是说由容器在运行期将组件间的某种依赖关系动态注入组件中

（2）使用IOC目的：为了耦合度降低

（3）做入门案例就是IOC实现

2. IOC底层原理

xml解析、工厂模式、反射

3. 图画讲解IOC底层原理

IOC（接口）

1. IOC思想基于IOC容器完成，IOC容器底层就是对象工厂

2. Spring提供IOC容器实现的两个接口：（两个接口）

（1）BeanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供开发人员使用

*加载配置文件的时候不会创建文件对象，在获取对象（使用）才去创建对象

（2）ApplicationContext ：BeanFatory接口的子接口，提供更多的更强大的功能，一般由开发人员的使用

*加载配置文件的时候就会把配置文件对象就行创建（在服务器启动的时候）

ApplicationContext接口的实现类：

如果配置文件放置在文件系统的路径下，则可以优先考虑使用 FileSystemXmlApplicationContext 实现类

如果配置文件放置在类路径下，用户可以优先使用 ：ClassPathXmlApplicationContext 实现类

IOC操作Bean管理（概念）

1. 什么是Bean管理？

（1）Bean管理指的是两个操作

（2）Spring创建对象

（3）Spring注入属性

2. Bean管理的操作有两种方式

（1）基于xml配置文件方式实现

（2）基于注解方式实现

IOC操作Bean管理（基于xml方式）

1. 基于xml方式创建对象

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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

<!-- 配置User对象创建 -->

<bean id ="user" class="pdsu.edu.spring5.User"></bean>

（1）在spring配置文件中，使用bean标签，标签里面添加对应的属性，就可以实现对象的创建

（2）在bean标签中有很多的属性，介绍常用的属性

*id属性：唯一标识

*class属性：类全路径（包类路径）

*name属性：早期的属性，一般不用，和id差不多，可以加符号

（3）创建对象时候，默认也是执行无参构造方法完成对象的创建

2.基于xml方式注入属性

（1）DI：依赖注入，就是注入属性

第一种注入方式：set方法注入

public class Orders {
	private String oname;
	private String address;

	public void setOname(String oname) {
		this.oname = oname;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public void order1() {
		System.out.println(oname+"::"+address);
	}	
}

下面是配置文件：

<!-- 2.set方法注入属性 -->
	<bean id="" class="">
		<!-- 使用property完成属性注入 name :类里面属性的名称 value：向属性中注入值 -->
		<property name="" value=""></property>
	</bean>

第二种注入方式：有参数构造方式进行注入

<!-- 3.有参数构造注入属性 -->
	<bean id="orders" class="pdsu.edu.testdemo.Orders">
	<constructor-arg name="oname" value="abc"></constructor-arg>
	<constructor-arg name="address" value="China"></constructor-arg>
	</bean>

下面添加了有参数的构造方法（5行-9行）

public class Orders {
	private String oname;
	private String address;
	//有参数的构造方法
	public Orders(String oname, String address) {
		super();
		this.oname = oname;
		this.address = address;
	}
	public void order1() {
		System.out.println(oname+"::"+address);
	}	
}

编写测试类

	public static void main(String[] args) {

		// 1.加载spring配置文件
		ApplicationContext con = new ClassPathXmlApplicationContext("bean1.xml");

		// 2.获取配置文件的对象
		Orders order = con.getBean("orders", Orders.class);
		System.out.println(order);
		order.order1();//order中的调用方法	
	}
}

第三种注入方式：p名称空间注入（了解，bname和bauthor类里面属性的名称）

IOC操作Bean管理（xml注入其他类型属性）

1. 字面量

（1）null值

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

（2）属性值包含特殊符号

属性中含有特殊符号 <<南京>>

? 1.把<>进行转义

//<   >
<property name="" >
		<value>&lt;南京&gt;</value>
</property>

? 2.把带特殊符号的内容写到CDATA

<property name="" >
		<value><![CDATA[<<南京>>]]></value>
</property>

2. 注入属性-外部bean

（1）创建两个类service类和dao类

public interface UserDao {

	public void update();
}

public class UserDaoImpl implements UserDao{
	public void update() {	
		System.out.println("dao update.........");
		
	}
}

（2）在service调用dao里面的方法

//2.创建UserDao类型属性，生成set方法
	private UserDao userDao;	
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}
	public void add() {
		// TODO Auto-generated method stub
		System.out.println("service add .........");	
		//1.原始方式:创建UserDao对象
//		UserDao userDao = new UserDaoImpl();
//		userDao.update();		
		userDao.update();

（3）在spring配置文件中进行配置

<bean id="userService" class="pdsu.edu.service.UserService">
		<!-- 注入userDao对象 name属性值：类里面的属性名称 ref属性：创建UserDao对象bean标签id值 -->
		<property name="userDao" ref="UserDaoImpl"></property>
</bean>
<bean id="UserDaoImpl" class="pdsu.edu.dao.UserDaoImpl"></bean>

(4)测试类:

public class test01 {
	public static void main(String[] args) {

		// 1.加载spring配置文件
		ApplicationContext con = new ClassPathXmlApplicationContext("bean2.xml");

		// 2.获取配置文件的对象
		UserService user = con.getBean("userService", UserService.class);
		System.out.println(user);
		user.add();//User中的调用方法		
	}
}

3. 注入属性-内部bean

（1）一对多的关系：部门和员工

一个部门可以有多个员工，一个员工属于一个部门

部门是一，员工是多

（2）在实体类之间表示一对多的关系，员工表示所属部门，使用对象类型属性进行表示

//部门类
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 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);
	}
}

（3）在spring中进行配置文件

<!--内部bean -->
	<bean id="emp" class="pdsu.edu.bean.Emp">
		<property name="ename" value="lucy"></property>
		<property name="gender" value="女"></property>
		<!-- 设置对象的属性 -->
		<property name="dept">
			<bean id="dept" class="pdsu.edu.bean.Dept">
				<property name="dname" value="保安部"></property>
			</bean>
		</property>
	</bean>

（4）测试类与上述差不多，略！

4. 注入属性-级联赋值

（1）第一种方法

<!--级联赋值 -->
	<bean id="emp" class="pdsu.edu.bean.Emp">
		<property name="ename" value="lucy"></property>
		<property name="gender" value="女"></property>
		<!-- 级联赋值ref指向下一个bean的id -->
		<property name="dept" ref="dept"></property>
	</bean>
	<bean id="dept" class="pdsu.edu.bean.Dept">
		<property name="dname" value="财务部"></property>
	</bean>

（2）第二种方法（需要添加get方法，8行-11行）

//员工类
public class Emp {
	private String ename;
	private String gender;
	//员工属于某一个部门，使用队形的形式
	private Dept dept;
    
	//添加了一个Dept的get方法
	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 id="emp" class="pdsu.edu.bean.Emp">
		<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="pdsu.edu.bean.Dept">
		<property name="dname" value="财务部"></property>
	</bean>

IOC操作Bean管理（xml注入集合属性）

1. 注入数组类型属性

2. 注入List集合类型属性

3. 注入Map集合类型属性

（1）创建类，定义数组，List，Map，Set，生成对应的set方法

public class Student {
	//1数组类型属性
	private String[] courses;
	//2.List集合类型属性
	private List <String> list;
	//3.Map集合类型属性
	private Map<String,String> maps;
	//4.Set类型集合属性
	private Set<String> setsSet;
	public void setSetsSet(Set<String> setsSet) {
		this.setsSet = setsSet;
	}
	public void setList(List<String> list) {
		this.list = list;
	}
	public void setMaps(Map<String, String> maps) {
		this.maps = maps;
	}
	public void setCourses(String[] courses) {
		this.courses = courses;
	}	
}

（3）在spring中进行配置文件的配置

<bean id="student" class="pdsu.edu.spring5.Student">
		<!-- 数组类型属性注入 -->
		<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="set">
			<set>
				<value>MySQL</value>
				<value>Redis</value>
			</set>
		</property>
	</bean>

4. 在集合里面设置对象类型值

<!-- 注入list集合类型值，值是对象 -->
		<property name="courseList">
		 <list>
		   <ref  bean="course1"></ref>
		   <ref  bean="course2"></ref>
		 </list>
		</property>

<!-- 创建多个course对象 -->
	<bean id="course1" class="pdsu.edu.spring5.Course">
		    <property name="cname" value="Spring5框架"></property>
		</bean>
		<bean id="course2" class="pdsu.edu.spring5.Course">
		    <property name="cname" value="MyBatis框架"></property>
		</bean>

5. 把集合注入部分提取出来

（1）在spring配置文件中引入名称空间util（第4行）

<?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"
	
	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:list id="bookList">
	<value>易筋经</value>
	<value>九阳真经</value>
	<value>九阳神功</value>
	</util:list>
	<!-- 2.提取list集合类型属性注入使用 -->
	<bean id="book" class="pdsu.edu.spring5.Book">
	<property name="list" ref="bookList"></property>
	</bean>

IOC操作Bean管理 （FactoryBean）

1. Spring有两种类型bean，一种是普通bean，另外一个是工厂bean（FactoryBean）

2. 普通bean：在spring配置文件中定义bean类型就是返回类型

3. 工厂bean：在配置文件中定义bean类型可以与返回类型不一样

? 第一步创建类：让这个类作为工厂bean，实现接口FactorBean

? 第二步实现接口里面的方法，在实现的方法中定义返回的bean类型

public class MyBean implements FactoryBean<Course>{
	//定义返回bean
	@Override
	public Course getObject() throws Exception {
		// TODO Auto-generated method stub
		Course course = new Course();
		course.setCname("abc");
		return course;
	}
	@Override
	public Class getObjectType() {
		// TODO Auto-generated method stub
		return null;
	}
}

测试类：

	// 1.加载spring配置文件
		ApplicationContext con = new  ClassPathXmlApplicationContext("bean3.xml");
		// 2.获取配置文件的对象
		Course user = con.getBean("myBean", Course.class);
		System.out.println(user);

配置文件是"pdsu.edu.FactoryBean.MyBean"

<bean id="myBean" class="pdsu.edu.FactoryBean.MyBean">	
</bean>

IOC操作Bean管理（bean作用域）

1. 在spring里面，设置创建bean实例是单实例还是多实例

2. 在spring里面，默认情况下，bean是单实例对象
   

3. 如何设置是单实例还是多实例

（1）在spring配置文件bean标签有属性（scope）用于设置是单实例还是多实例

（2）Scope属性值：

? 第一个值，默认值，singleton表示单实例对象

? 第二个值，prototype表示多实例对象

以下表示修改（scope=“prototype”）后的结果：

（3）区别singleton，prototype，Request（了解），Ression（了解）

第一：singleton表示单实例对象，prototype表示多实例对象

第二：设置scope值是singleton时候，加载spring配置文件时候就会创建单实例对象

? 设置scope值为prototype时候，不是在加载spring配置文件的时候创建对象，在调用getBean方法时候创建多个实例化对象

IOC操作Bean管理（bean生命周期）

1. 生命周期

（1）从对象的创建到对象的销毁的过程

2. bean生命周期

（1）通过构造器创建bean实例（无参数构造）

（2）为bean的属性设置值和对其他bean引用（调用set方法）

（3）调用bean的初始化的方法（需要进行配置初始化方法）

（4）bean可以使用了（对象获取到了）

（5）当容器关闭的时候，调用bean的销毁的方法（需要进行配置销毁的方法）

3. 演示bean生命周期

public class Order {
	//无参数构造
	public Order() {
		System.out.println("第一步 执行无参构造创建bean创建");
	}
	private String oname;

	public void setOname(String oname) {
		this.oname = oname;
		System.out.println("第二步 调用set方法设置属性值");
	}
	//创建执行的初始化方法
	public void init() {
		System.out.println("第三步  执行初始化方法");
	}
	//创建销毁的初始化方法
		public void destroy() {
			System.out.println("第五步  执行销毁的方法");
		}
}

创建测试类：

// 1.加载spring配置文件
		ApplicationContext con = new ClassPathXmlApplicationContext("bean4.xml");

		// 2.获取配置文件的对象
		Order order = con.getBean("order", Order.class);
		System.out.println("第四步  获取创建的bean实例化对象");
		System.out.println(order);
		  //手动让bean实例化销毁
		((ClassPathXmlApplicationContext)con).close();

配置文件：

<bean id="order" class="pdsu.edu.Bean.Order" init-method="init" destroy-method="destroy">
	<property name="oname" value="手机"></property>
</bean>

运行结果：

? 第一步 执行无参构造创建bean创建

? 第二步 调用set方法设置属性值

? 第三步 执行初始化方法

? 第四步 获取创建的bean实例化对象

? pdsu.edu.Bean.Order@2ac273d3

? 第五步 执行销毁的方法

4. bean的后置处理器，bean生命周期有七步

（1）通过构造器创建bean实例（无参数构造）

（2）为bean的属性设置值和对其他bean引用（调用set方法）

（3）把bean实例传递bean后置处理器的方法 （postProcessBeforeInitialization）

（4）调用bean的初始化的方法（需要进行配置初始化方法）

（5）把bean实例传递bean后置处理器的方法（ postProcessAfterInitialization）

（6）bean可以使用了（对象获取到了）

（7）当容器关闭的时候，调用bean的销毁的方法（需要进行配置销毁的方法）

5. 演示添加后置处理器效果（在刚刚基础上添加，创建MybeanPost）

public class MybeanPost implements BeanPostProcessor {

	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("在初始化之前执行的方法");
		return bean;
	}
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		// TODO Auto-generated method stub
		System.out.println("在初始化之后执行的方法");
		return bean;
	}
}

配置文件：

<bean id="order" class="pdsu.edu.Bean.Order" init-method="init" destroy-method="destroy">
	<property name="oname" value="手机"></property>
	</bean>
	<!-- 配置后置处理器 -->
	<bean id="myBeanPost" class="pdsu.edu.Bean.MybeanPost"></bean>

运行结果：

? 第一步 执行无参构造创建bean创建

? 第二步 调用set方法设置属性值

? 在初始化之前执行的方法

? 第三步 执行初始化方法

? 在初始化之后执行的方法

? 第四步 获取创建的bean实例化对象

? pdsu.edu.Bean.Order@56235b8e

? 第五步 执行销毁的方法

IOC操作Bean管理（xml自动装配）

1.什么是自动装配

（1）根据指定装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行注入.

2.演示自动装配过程

（1）根据属性名称自动注入

<!-- 实现自动装配
	bean标签属性autowire，配置自动装配
	autowire属性常用两个值：
	byName根据属性名称注入，注入值bean的id值和类属性名称一样
	byType根据属性类型注入
	 -->
	<bean id="emp" class="pdsu.edu.Bean.Emp"  autowire="byName">
	<property name="dept" ref="dept" ></property>
	</bean>
	<bean id="dept" class="pdsu.edu.Bean.Dept"></bean>

(2)根据属性类型自动注入(相同的名称不能dept1等)

<bean id="emp" class="pdsu.edu.Bean.Emp"  autowire="byType">
	<property name="dept" ref="dept" ></property>
	</bean>
	<bean id="dept" class="pdsu.edu.Bean.Dept">
     <!-- 会报错  <bean id="dept1" class="pdsu.edu.Bean.Dept"> -->
 </bean>

IOC操作Bean管理（外部属性文件）

1.直接配置数据库信息

（1）配置德鲁伊连接池

（2）引入德鲁伊连接池依赖的jar包

链接：
提取码：938i

<!--com.alibaba.druid.pool.DruidDataSource 这是它的数据源-->
<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="123456"></property>
	</bean>

2.引入外部属性文件配置数据库连接池

(1)创建外部属性文件，properties格式文件，写入数据库数据信息

（2）把外部properties属性文件引入到spring配置文件中

*引入context名称空间（4,9,10行）

<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"
	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">

在spring配置文件中使用标签引入外部属性文件

     <!-- 先引入外部属性文件 -->
	<context:property-placeholder  location="classpath :jdbc.properties"/>
	<!-- 直接配置连接池 -->
	<bean id="dataSource"
		class="com.alibaba.druid.pool.DruidDataSource">
		<property name="driverClassName"
			value="${prop.driverClassName}"></property>
		<property name="url" value="${prop.url}"></property>
		<property name="username" value="${prop.username}"></property>
		<property name="password" value="${prop.password}"></property>
	</bean> 

IOC操作Bean管理（基于注解方式）

1.什么是注解

（1）注解是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值…)

（2）使用注解，注解作用在类的上面，方法的上面，属性上面

（3）使用注解的目的：简化xml配置

2.Spring针对Bean管理中创建对象提供注解

（1）@Component

（2）@Service

（3）@Controller

（4）@Repository

*上面的注解功能都是一样的，都可以用来创建建bean实例

3.基于注解方式实现对象创建

第一步引入依赖

第二步开启组件扫描

<!-- 开启组件扫描，如果扫描多个包 
    1.多个包使用逗号隔开pdsu.edu.dao,pdsu.edu.service
    2.扫描包的上层目录pdsu.edu -->
	<context:component-scan
		base-package="pdsu.edu.dao,pdsu.edu.service"></context:component-scan>

第三步 创建类，再类上面添加创建对象注解(@Component使用其他注解也可以)

//在注解里面value属性值可以省略不写
//默认值是类名称，首字母小写
//UserService--userService
@Component(value="userService")//<bean id ="userService" class="..."/>
public class UserService {
	public void add() {
		System.out.println("service add........");
	}
}

4.开启组件扫描中的细节

<!-- 示例1 use-default-filters="false"表示现在不是用默认filter，自己配置filter
    context:include-filter,设置扫描哪些内容，这里是扫描@Service注解 -->
	<context:component-scan  base-package="pdsu.edu.service" use-default-filters="false">
		<context:include-filter type="annotation"
			expression="org.springframework.stereotype.Service" />
	    </context:component-scan>

	<!-- 示例2 context:exclude-filter设置哪些内容不去扫描，这里是不扫描@Service注解 -->
	<context:component-scan
		base-package="pdsu.edu.service">
		<context:exclude-filter type="annotation"
			expression="org.springframework.stereotype.Service" />
	</context:component-scan>

5.基于注解方式实现属性注入

（1）@AutoWired：根据属性类型进行自动装配

第一步把service和dao对象创建,在service和dao类中添加创建对象注解

第二步 在service注入dao对象，在service类添加dao类型属性，在属性上面使用注解

@Service
public class UserService {

	//定义dao类型属性
	//不需要添加set方法
	//添加注入属性注解
	@Autowired//根据类型进行注入
	private UserDao userDao;
	public void add() {
		System.out.println("service add........");
	}
}

UserDaoImpl类

@Repository(value = "userDaoImpl1")
public class UserDaoImpl implements UserDao {

	public void add() {
		System.out.println("dao add........");
	}
}

接口UserDao:

public interface UserDao {
    public 	void add();
}

*最后编写测试类即可（别忘了xml配置文件，里面只需开启注解扫描）！

（2）@Qualifier：根据属性名称进行注入

@Qualifier这个注解的使用要和@AutoWired一起使用

（有多个接口的时候需要）

//定义dao类型属性
	//不需要添加set方法
	//添加注入属性注解
	@Autowired //根据类型进行注入
	@Qualifier(value = "userDaoImpl1")//根据名称进行注入
	private UserDao userDao;

注意下面value = “userDaoImpl1” 名字自己定义，上面根据@Qualifier(value = “userDaoImpl1”)来寻找

@Repository(value = "userDaoImpl1")
public class UserDaoImpl implements UserDao {

	public void add() {
		System.out.println("dao add........");
	}
}

（3）@Resource：可以根据类型注入，可以根据名称注入

Resource在javax包中（扩展包），上面两个在spring中

//@Resource//根据类型注入
	@Resource(name = "userDaoImpl1")//根据名称进行注入
	private UserDao userDao;	
	public void add() {
		System.out.println("service add........");
		userDao.add();
	}

（4）@Value：注入普通类型（此时 name=abc）

	@Value(value="abc")
	private String name;

6.完全注解开发（没有配置文件,此方法了解即可）

（1）创建配置类，替代xml配置文件

@Configuration//作为配置类，替代xml配置文件
@ComponentScan(basePackages= {"pdsu.edu"})
/*相当于开启注解扫描
 * <context:component-scanbase-package="pdsu.edu">
 *               </context:component-scan>*/
public class SpringConfig {

}

（2）编写测试类（第4行和其他方式不同）

public class test2 {
	public static void main(String[] args) {
		// 1.加载spring配置文件
		ApplicationContext con = new AnnotationConfigApplicationContext(SpringConfig.class);
		// 2.获取配置文件的对象		
		  UserService user = con.getBean("userService", UserService.class);
		  System.out.println(user); 
		  user.add();//User中的调用方法	 		
	}

后续笔记会持续更新，希望大家给个一键三连！！！！！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XW0WPfko-1633518013742)(C:\Users\Administrator\Pictures\img\image-20211006180852204.png)]

…");
}
}

（3）@Resource：可以根据类型注入，可以根据名称注入

Resource在javax包中（扩展包），上面两个在spring中

```java
//@Resource//根据类型注入
	@Resource(name = "userDaoImpl1")//根据名称进行注入
	private UserDao userDao;	
	public void add() {
		System.out.println("service add........");
		userDao.add();
	}

（4）@Value：注入普通类型（此时 name=abc）

	@Value(value="abc")
	private String name;

6.完全注解开发（没有配置文件,此方法了解即可）

（1）创建配置类，替代xml配置文件

@Configuration//作为配置类，替代xml配置文件
@ComponentScan(basePackages= {"pdsu.edu"})
/*相当于开启注解扫描
 * <context:component-scanbase-package="pdsu.edu">
 *               </context:component-scan>*/
public class SpringConfig {

}

（2）编写测试类（第4行和其他方式不同）

public class test2 {
	public static void main(String[] args) {
		// 1.加载spring配置文件
		ApplicationContext con = new AnnotationConfigApplicationContext(SpringConfig.class);
		// 2.获取配置文件的对象		
		  UserService user = con.getBean("userService", UserService.class);
		  System.out.println(user); 
		  user.add();//User中的调用方法	 		
	}

后续笔记会持续更新，希望大家给个一键三连！！！！！