Spring5 IOP轻松学习

下载spring

我们可以在网上写载，通过以下链接下载
点击下载spring
在这里面我们选择5.2.9版本的spring，下载之后解压

解压之后就是上图。
接下来我们就创建一个入门案列，打开我们的编译工具IDEA，创建一个普通的JAVA工程

创建之后我们需要引入几个包，我们在IDEA中创建一个lib用来存放这些包

这些包在我们下载的spring中的libs中
我们打开这个包找到这些jar包

我们还需要一个日志文件：这里面没有需要我们去下载

下载之后解压

我们只需要把这5个jar拷贝到我们的IDEA中就可以了，然后我们在点击

把我们的jar包拷贝进去就可以了

我们的准备工作就写好了，我们做一个实列把
1.创建一个User.java类在这里面写

创建我们的spring配置文件，在配置文件中配置创建对象

xml的名字没有要求，我这里写的是spring.xml你们可以随便写，
我们在spring.xml中配置创建的对象

<bean id="user" class="com.xiaoran.spring5.bean.User">

这个bean就是用来配置创建对象，id=“ 是我们用来创建的对象名字自己取的” ，class=“ 这里面是写我们的类路径”

我们在写以测试类Testdemo.java
在这个类中写

@Test
public void Testdemo(){//这个是加载我们的spring配置文件ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");//获取到spring.xml中的具体bean，然后创建对应的对象 ，getbean("这里面写的是我们在spring.xml中的bean的id",这里写的就我们需要转换的类型)User user=context.getBean("user",User.class);System.out.println(user);//这里输出的是我们 的路径user.add();//调用我们在User.java中写的方法
}

我们的第一个测试类就写好了
总结

首先创建一个User.java类
把我们创建的类配置到spring.xml中去
通过测试类中的ApplicationContext加载我们的spring配置文件

IOC接口

IOC的接口有两种

BeanFactory:这个是spring自带的，加载配置文件时不会去创建对象只有在获取对像时去创建对象
ApplicationContext：这个是我们经常使用的，加载配置文件时就会把配置文件对象创建

IOC注入

无参注入:我们重新创建一个新的类Book.java

public class Book {private String name;private String zuozhe;public void setName(String name) {this.name = name;}public void setZuozhe(String zuozhe) {this.zuozhe = zuozhe;}public void ran() {System.out.println("输出的结果为：" + name + "----" + zuozhe);}
}

2.我们在spring.xml中把我们新创建的类配置进去
在bean标签中我们用property标签完成属性注入（无参注入）

<bean id="book" class="com.xiaoran.spring5.bean.Book">
<!--
name=“这里面写的内容是我们需要注入类中的属性名称”
value=“这是我们需要给属性注入的内容”
-->
<property name="name" value="小明同学"></property>
<property name="zuozhe" value="小冉"></property>
</bean>

3.我们在写一个测试类用来看一下结果

 @Testpublic void TestBook(){//加载配置文件ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");//获取配置创建对象Book book=context.getBean("book",Book.class);System.out.println(book);book.ran();}

以上就是无参注入的内容

**2.**有参注入
1.我们新创建一个新的类Order.java

public class Order {private String name;private int age;public Order(String name, int age) {this.name = name;this.age = age;}public void rr(){System.out.println(name+"----"+age);}
}

2.在spring.xml中配置我们新创建的类
有参注入我们使用的是constructor-arg标签

 <bean id="order" class="com.xiaoran.spring5.bean.Order"><constructor-arg name="name" value="小帅"></constructor-arg><constructor-arg name="age" value="18"></constructor-arg>
</bean>

3.在写一个测试类

 @Testpublic void Testorder(){//加载配置文件ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");//获取配置创建对向Order order=context.getBean("order",Order.class);System.out.println(order);order.rr();}

以上是无参注入

当我们注入特殊字符串或null时的注入方法

1.注入null
我们在spring.xml中配置我需要设置为null的属性时这样写

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

这样我们输出的时候我们的name的值就是为null，如果用value=“”输出的话结果肯定是会报错的
2.注入尖括号
有两种方法可以实现注入

把<>近行转义注入
把带特殊符号的内容写入到CDATA中

第一种转义之后输出，这个是最简单的

<!--
&lt; 就是<
&gt; 就是>
--><property name="zuozhe" value="&lt;日本&gt;"></property>

第二种是通CDATA写入

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

这种也可以，看自己喜欢哪一种

Bean注入属性（外部注入）

我们通过实列来了解

创建两个类一个service 和一个dao类
我们在service类中调用dao类
在我们上面的实列中都是对String类型赋值，如果我们是对一个对象类型进行赋值的话就要使用我们的外部注入

接下来我们就开始实现一下吧
1.创建一个dao包在包中写一个UserDao.java接口和一个UserDaoImpl.java类
UserDao.java:

public interface UserDao {public void update();
}

UserDaoImpl.java:

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

2.创建一个service包在包中写一个Userservice.java在这里面写

package com.xiaoran.spring5.service;import com.xiaoran.spring5.dao.UserDao;public class Userservice {//创建UserDao类型属性，生成set方法private UserDao userDao;public void setUserDao(UserDao userDao) {this.userDao = userDao;}public void add(){System.out.println("Service add.................");userDao.update();}
}

3.我们配置sprig.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"><!--1.service和Dao对象的创建--><bean id="userservice" class="com.xiaoran.spring5.service.Userservice"><!--注入UserDao对象name属性:类里面属性的名称ref属性：创建userdao对象标签中的id--><property name="userDao" ref="userdao"></property></bean><bean id="userdao" class="com.xiaoran.spring5.dao.UserDaoImpl"></bean>
</beans>

4.写一个测试方法：

package com.xiaoran.spring5.testdemo;import com.xiaoran.spring5.bean.Book;
import com.xiaoran.spring5.bean.Order;
import com.xiaoran.spring5.bean.User;
import com.xiaoran.spring5.service.Userservice;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class Test2 {@Testpublic void TestBean(){//获取spring的配置文件ApplicationContext context =new ClassPathXmlApplicationContext("spring2.xml");Userservice userservice=context.getBean("userservice",Userservice.class);System.out.println(userservice);userservice.add();}
}

最后我们测试的结果显示为

外部注入对像应该来说是很简单的所以没有多说；

Bean注入属性-（内部注入）

1.我们创建两个类一个为Dept.java（部门类）和Emp.java(员工类)，这两种类对应的关系就是为一对多
2.配置spring.xml为内部注入对象

1.在Dept.java中写：写以个部门名称dname，set方法，tostring（）

package com.xiaoran.spring5.bean2;public class Dept {private  String dname;public void setDname(String dname) {this.dname = dname;}@Overridepublic String toString() {return "Dept{" +"dname='" + dname + '\'' +'}';}
}

2。在Emp.java中写：写一个ename（员工姓名）,gender(性别)，dept(我们对应的部门名称)，在写一个add（）方法用来显示内容

package com.xiaoran.spring5.bean2;public class Emp {private String ename;private  String gender;private  Dept dept;public void setEname(String ename) {this.ename = ename;}public void setGender(String gender) {this.gender = gender;}public void setDept(Dept dept) {this.dept = dept;public void add(){System.out.println(ename+"::"+gender+"::"+dept);}}

3.在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 http://www.springframework.org/schema/beans/spring-beans.xsd"><!--内部bean的操作--><bean id="emp" class="com.xiaoran.spring5.bean2.Emp" ><!--设置两个普通属性--><property name="ename" value="小冉"></property><property name="gender" value="男"></property><!--设置对象类属性Dept--><property name="dept"><bean id="dep" class="com.xiaoran.spring5.bean2.Dept"><property name="dname" value="中国保安队"></property></bean></property></bean>
</beans>

4.写一个测试类我们来查看一下结果

package com.xiaoran.spring5.testdemo;import com.xiaoran.spring5.bean2.Emp;
import com.xiaoran.spring5.service.Userservice;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class Test3 {@Testpublic void TestBean(){ApplicationContext context=new ClassPathXmlApplicationContext("spring3.xml");Emp emp=context.getBean("emp",Emp.class);emp.add();}
}

最后我们看到的结果就是：

xml中注入注入数组属性；

注入数组类型
List集合注入
Map类型注入
set类型属性注入

接下来我们就用一个列子来把这些全部实现一下
1.创建一个collectiontype包在这个包中创建一个Stu.java类在类中写

package com.xiaoran.spring.collectiontype;import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;public class Stu {private String[] arrays;private List<String> list;private Map<String,String> map;private Set<String> set;public void setArrays(String[] arrays) {this.arrays = arrays;}public void setList(List<String> list) {this.list = list;}public void setMap(Map<String, String> map) {this.map = map;}public void setSet(Set<String> set) {this.set = set;}public  void add(){System.out.println("数组："+Arrays.toString(arrays));//这里面数组是不可以直接输出的所以我把他装换为string输出System.out.println("LIst"+list);System.out.println("MAP："+map);System.out.println("Set:"+set);}
}

2.在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 http://www.springframework.org/schema/beans/spring-beans.xsd"><!--数组配置--><bean id="stu" class="com.xiaoran.spring.collectiontype.Stu"><property name="arrays"><array><value>Java课程</value><value>python课程</value></array></property><!--list集合注入--><property name="list"><list><value>张三</value><value>李四</value></list></property><!--map集合注入：这里因为Map是键值对类型所以用key—value--><property name="map"><map><entry key="php" value="小芳"></entry><entry key="java" value="小冉"></entry></map></property><!--set集合注入--><property name="set"><set><value>mysql</value><value>orderl</value></set></property></bean>
</beans>

3.我写一个测试类来描写：

package com.xiaoran.spring.Testdemo;import com.xiaoran.spring.autowire.Emp;
import com.xiaoran.spring.collectiontype.Book;
import com.xiaoran.spring.collectiontype.Conser;
import com.xiaoran.spring.collectiontype.Stu;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import sun.security.krb5.internal.APOptions;public class Test1 {@Testpublic void test1(){ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");Stu stu=context.getBean("stu",Stu.class);stu.add();}
}

测试出来的结果

到这里我们的类型注入也就完成了，还有一些细节上的问题

细节（如果我们注入的是一个集合类型的对象）

1.我们在Stu.java中写一门课程注入（conser），因为课程有多门所以我们是List类型
2。创建一个Conser.java类

在Conser.java中写：一个我们的课程名称（name）

package com.xiaoran.spring.collectiontype;public class Conser {private String  name;public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Conser{" +"name='" + name + '\'' +'}';}
}

在Stu.java中写

package com.xiaoran.spring.collectiontype;import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;public class Stu {private String[] arrays;private List<String> list;private Map<String,String> map;private Set<String> set;//学生多门课程的数组注入，类型为对象private  List<Conser> conser;public void setConser(List<Conser> conser) {this.conser = conser;}public void setArrays(String[] arrays) {this.arrays = arrays;}public void setList(List<String> list) {this.list = list;}public void setMap(Map<String, String> map) {this.map = map;}public void setSet(Set<String> set) {this.set = set;}public  void add(){System.out.println("数组："+Arrays.toString(arrays));System.out.println("LIst"+list);System.out.println("MAP："+map);System.out.println("Set:"+set);System.out.println("课程表的插入："+conser);}
}

3.我在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 http://www.springframework.org/schema/beans/spring-beans.xsd"><!--数组配置--><bean id="stu" class="com.xiaoran.spring.collectiontype.Stu"><property name="arrays"><array><value>Java课程</value><value>python课程</value></array></property><property name="list"><list><value>张三</value><value>李四</value></list></property><property name="map"><map><entry key="php" value="小芳"></entry><entry key="java" value="小冉"></entry></map></property><property name="set"><set><value>mysql</value><value>orderl</value></set></property><!--数组类型的对象注入--><property name="conser"><list><!--这个ref标签中引用的 bean=“”必须对应我们下面bean标签中的id而我们是数组类型，我们需要传入多少个值外面就写几个bean，然后把id写入进来就可以了--><ref bean="conser1"></ref><ref bean="conser2"></ref></list></property></bean><bean id="conser1" class="com.xiaoran.spring.collectiontype.Conser"><property name="name" value="小冉还是帅"></property></bean><bean id="conser2" class="com.xiaoran.spring.collectiontype.Conser"><property name="name" value="小冉还是帅"></property></bean>
</beans>

4，最后我写一个测试类：

package com.xiaoran.spring.Testdemo;import com.xiaoran.spring.autowire.Emp;
import com.xiaoran.spring.collectiontype.Book;
import com.xiaoran.spring.collectiontype.Conser;
import com.xiaoran.spring.collectiontype.Stu;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import sun.security.krb5.internal.APOptions;public class Test1 {@Testpublic void test1(){ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");Stu stu=context.getBean("stu",Stu.class);stu.add();}}

最后结果显示：：

细节二（公共注入）

1.我们如果每次注入的数据都是一样的话我们就可以使用一个公共注入了呀，这样就不需要每次都重复去写，
2.我们在使用公共注入的时候需要去引入util
3.然后我们使用util标签去完成List集合注入提取
4.在spring中操作

1.创建一个类Book.java在类中写：一个图书名称是字符数组

package com.xiaoran.spring.collectiontype;import java.util.List;public class Book {private List<String> Bname;public void setBname(List<String> bname) {Bname = bname;}public void test(){System.out.println(Bname);}
}

2。在spring.xml中注入值（引入util）
引入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"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

在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"xmlns:util="http://www.springframework.org/schema/util"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"><!--1.公共集合属性注入util:list标签--><util:list id="bookList"><value>九阳</value><value>mysql</value></util:list><!--2.提取list集合属性注入ref=“” 等于我们在util:list标签中的id--><bean id="book1" class="com.xiaoran.spring.collectiontype.Book" ><property name="Bname" ref="bookList"></property></bean>
</beans>

3。我们写一个测试类来看一下我们的结果：

    @Testpublic void test3(){ApplicationContext context=new ClassPathXmlApplicationContext("spring2.xml");Book book=context.getBean("book1",Book.class);book.test();}

最后我们看一下我们输出的结果：

Spring.xml中Bean的类型

bean有两种类型：一种是普通bean，一种是工厂bean
普通bean：在配置文件中定义的bean类型就是我们最后返回结果类型，我们之前写的都是这种

接下来我们重点介绍一下工厂bean：
在配置文件中定义的bean类型可以和返回类型不一样。
。实现过程：
第一步：创建类让他做为工厂bean实现接口FactoryBean
第二步：实现接口里面的方法，在实现方法中定义返回bean类型
1.创建一个：Conser.java:

package com.xiaoran.spring.collectiontype;public class Conser {private String  name;public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "Conser{" +"name='" + name + '\'' +'}';}
}

2.创建testBean.java类实现接口FactoryBean，
FactoryBean自带了三个方法：

     public object  getObject() //返回bean实列public Class<?> getObjectType() //返回bean类型public boolean isSingleton() //单例

package com.xiaoran.spring.factorybean;import com.xiaoran.spring.collectiontype.Conser;
import org.springframework.beans.factory.FactoryBean;public class testBean implements FactoryBean<Conser> {@Overridepublic Conser getObject() throws Exception {Conser conser=new Conser();//在创建Conser类conser.setName("abc");//调用setName()方法return conser;//返回conser}@Overridepublic Class<?> getObjectType() {return null;}@Overridepublic boolean isSingleton() {return false;}
}

3.在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"xmlns:util="http://www.springframework.org/schema/util"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"><bean id="testBean" class="com.xiaoran.spring.factorybean.testBean"></bean>
</beans>

4。写一个测试类：

    @Testpublic void test4(){ApplicationContext context=new ClassPathXmlApplicationContext("Spring3.xml");//这里或许你们会有疑惑为什么我们的getBean获取的结果是Conser类型而不是testBean类型，//这是因为我们在testBean.java这个类中我们去改变了放回值的类型为ConserConser conser=context.getBean("testBean",Conser.class);System.out.println(conser);}

最后我们来看一下我们最后的结果显示为：

bean自动装配

根据指定装配规则（属性名称或者属性类型），在spring.xml自动匹配的属性值进行注入
2.需要要在bean标签中添加一个新的属性 autowire=“byName || byType”
byName：表示根据属性名称注入（细节我们注入bean的id要和类属性名称一样）
byType：表示根据属性类型注入

我们来测试一下：创建Dept.java类和Emp.java类
在Dept.java中写

package com.xiaoran.spring.autowire;public class Dept {@Overridepublic String toString() {return "Dept{}";}
}

在Emp.java中写：在Emp.java中注入一个Dept对象

package com.xiaoran.spring.autowire;public class Emp {private Dept dept;public void setDept(Dept dept) {this.dept = dept;}@Overridepublic String toString() {return "Emp{" +"dept=" + dept +'}';}public void test(){System.out.println(dept);}
}

2.在spring.xml中配置bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:util="http://www.springframework.org/schema/util"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd"><!--实现自动装配bean标签属性autowrie，autowire属性常用两个值:![请添加图片描述](https://img-blog.csdnimg.cn/8754ddb44b2148b8bc208d5ace045ab2.jpg?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5bCP5YaJMQ==,size_20,color_FFFFFF,t_70,g_se,x_16)
byname根据属性名称注入，注入值bean和id值和类属性名称一样bytype根据属性类型注入--><bean id="emp" class="com.xiaoran.spring.autowire.Emp" autowire="byType"></bean><bean id="dept" class="com.xiaoran.spring.autowire.Dept"></bean></beans>

这里有两种情况如果我们是才用根据属性名称注入是没有问题的。
但是如果我们按照类型注入的话，就会出现只有一个类型，但是需要多个注入，注意这样就不可用使用根据属性注入。

3.我们写一个测试类：

  @Testpublic void test5(){ApplicationContext context=new ClassPathXmlApplicationContext("spring4.xml");Emp emp=context.getBean("emp",Emp.class);System.out.println(emp);}

测试结果：

IOC操作（外部文件引入）

1.我在使用spring.xml配置的时候有很多是单独的内容，我们完全没有必要写在spring.xml中
2.比如我的数据库引入配置，我们用一个数据库的列子来说明怎么使用
列1
1.配置数据库的连接池（需要引入德鲁伊连接池）
这里面有这个包

这是免费的大家下载解压之后放到lib中然后添加一下就可以了，和之前的一样
2.我们需要创建一个jdbc.properties文件来写我们需要引入的内容

prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/book
prop.userName=root
prop.password=mysql123456

3.接下就可以在spring.xml中写
注意需要引入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: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.xsdhttp://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"><!--引入外部属性文件--><context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder><!--配置数据库连接池--><bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="${prop.driverClass}"></property><property name="url" value="${prop.url}"></property><property name="username" value="${prop.userName}"></property><property name="password" value="${prop.password}"></property></bean>
</beans>

Ban管理（基于注解方式）

格式：@注解名称（属性名称=属性值，属性名称=属性值）
注解可以写在类上面也可以写在方法上面，可以达到简化代码的做用
2.在spring.xml中针对Bean管理进行对象创建：

@component 针对普通创建
@service 针对业务层
@controller 针对web层
@Repository 针对持久层，dao层
这4个注解都可以达到同样的效果就是创建对象，我们上面写的只是我们一般作用于上面地方
我们举个列子吧：
1.创建Test1.java类在类中写一个方法add(),我们这里使用了一个注解@component

package com.xiaoran.spring.bean;import com.xiaoran.spring.dao.UserDao;
import com.xiaoran.spring.dao.UserDaoImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.ImportResource;
import org.springframework.stereotype.Component;
//这个注解的意思就相当于我们以前bean标签中的id
//在下面的注解中其实我们可以忽略不写value的值，spring会自动给我们装配，默认是我们类名首字母小写
@Component(value="test1")
public class Test1 {public void add(){System.out.println("小冉还是很帅");}
}

2.我们配置了注解就必须要在spring.xml中开启注解扫描
我们需要在spring.xml 中添加一个标签context
在context：component-scan base-pack="这里面我们写的就是指定的包也就我们去扫描的范围 "

<?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 https://www.springframework.org/schema/context/spring-context.xsd"><!--配置扫描组件--><context:component-scan base-package="com.xiaoran.spring"></context:component-scan>
</beans>

3.我们只需要一个测试类就可以查看我们的结果了

    @Testpublic void test1(){ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml") ;Test1 test1=context.getBean("test1",Test1.class);System.out.println(test1);test1.add();}

最后的结果也是不出我们所料的
.
接下来我们就说一下我们在spring.xml中配置扫描组件的细节实现：
1。我们可以指定我们想要扫描的内容
在spring.xml 中写

<!--指定我们想要扫描的包--><!--属性解说：use-default-filters="false" ：这个属性的为true的意思就是我们使用默认的规则（也就是匹配所有），这属性为false的意思就是我们自己配置规则include-filter：意思是包含在这里面的匹配type="annotation"：意思是针对类型为注解 的expression="org.springframework.stereotype.Controller"：意思是只匹配我们指定的注解controller--><context:component-scan base-package="com.xiaoran.spring" use-default-filters="false"><context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"></context:include-filter></context:component-scan>

2.扫描包中所有内容
在spring.xml中写

    <!--指定我们想要扫描的包--><!--属性解说：use-default-filters="false" ：这个属性的为true的意思就是我们使用默认的规则（也就是匹配所有），这属性为false的意思就是我们自己配置规则exclude-filter：意思是包含在这里面的匹配type="annotation"：意思是针对类型为注解 的expression="org.springframework.stereotype.Controller"：意思是只匹配我们指定的注解controller--><context:component-scan base-package="com.xiaoran.spring"><context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"></context:exclude-filter></context:component-scan>

基于注解的扫描注入

上面我们是用注解创建对象，这里面我们注解来注入值

@AutoWried 根据属性类型注入
@Qualifier 根据属性名称注入
@Resource 可以根据类型注入也可以根据名称注入
@Value 普通注入

接下来我们一个一个实现一下：
@AutoWried使用
1.我新创建两个包service 和dao包
在dao中写UserDao.java和UserDaoImpl.java实现接口类
在UserDaoImpl.java中写

package com.xiaoran.spring.dao;public interface UserDaoImpl {public void add1();
}

在UserDao.java中写

package com.xiaoran.spring.dao;import org.springframework.stereotype.Component;@Component
public class UserDao implements UserDaoImpl {public void add1(){System.out.println("大家早上好");}
}

2.我们在创建一个Test1.java类，我在这个类中注入对象UserDao类，我们在使用类注解@AutoWired之后就不需要去添加set方法，注解会自动帮我们完成

package com.xiaoran.spring.bean;import com.xiaoran.spring.dao.UserDao;
import com.xiaoran.spring.dao.UserDaoImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.ImportResource;
import org.springframework.stereotype.Component;@Component
public class Test1 {@Autowiredprivate UserDao userDao;public void add(){System.out.println("小冉还是很帅");userDao.add1();}
}

3.我们下一个测试类来查看一下结果；

    @Testpublic void test1(){ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml") ;Test1 test1=context.getBean("test1",Test1.class);System.out.println(test1);test1.add();}

2.@Qualifier在使用过程中必须要配合@AutoWired一起使用
我们只需要在上面代码的基础上简单修改一下就可以
修改Test1.java中

package com.xiaoran.spring.bean;import com.xiaoran.spring.dao.UserDao;
import com.xiaoran.spring.dao.UserDaoImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.ImportResource;
import org.springframework.stereotype.Component;@Component
public class Test1 {@Autowired@Qualifier(value = "emp")private UserDao userDao;public void add(){System.out.println("小冉还是很帅");userDao.add1();}
}

在UserDao.java中修改

package com.xiaoran.spring.dao;import org.springframework.stereotype.Component;@Component(value = "emp")
public class UserDao implements UserDaoImpl {public void add1(){System.out.println("大家早上好");}
}

3.测试不需要改变直接执行发现结果还是一样的

@Resource的用法和上面的相同，就不说了大家自己取尝试吧

接下我们说一下纯注解开发

纯注解开发就是，不需要xml文件，我们只需要创建一个配置类，替代xml`
创建一个SpringConfig.java添加注解@Configuration表示作为配置类用来替代xml配置文件
在添加一个注解@ComponentScan(basePackages= {“com.xiaoran.spring”})，这个注解等同于我们以前在spring.xml中写的配置扫描组件内容

package com.xiaoran.spring.config;import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan(basePackages= {"com.xiaoran.spring"})
public class SpringConfig {}

我们的springConfig.java类写好之后我们就写个测试类来测试一下：
这一次的测试类和以往的测试类有一点区别，我们以前是获取的spring.xml配置而现在是获取我们创建的配置类springConfig.class

  @Testpublic void test2(){ApplicationContext context=new AnnotationConfigApplicationContext(SpringConfig.class);Test1 test1=context.getBean("test1",Test1.class);System.out.println(test1);test1.add();}

之后我们再执行结果也是和之前的相同

springIOC的内容就讲完了大家多练习一下吧