IOC

介绍：
在Spring的应用中，Spring IoC容器可以创建、装配和配置应用组件对象，这里的组件对象称为Bean。

Bean的实例化

在面向对象编程中，想使用某个对象时，需要事先实例化该对象。同样，在Spring框架中，想使用Spring容器中的Bean，也需要实例化Bean。Spring框架实例化Bean有3种方式：构造方法实例化、静态工厂实例化和实例工厂实例化，其中，最常用的实例方法是构造方法实例化。
创建配置类
在应用的src目录下，创建config包，并在该包中创建配置类JavaConfig。在该配置类中使用@Bean定义3个Bean，具体代码如下：

IOC操作bean管理（普通bean)

spring有两种类型bean,一种普通bean,另外一种工厂bean
普通bean:在配置文件中定义的什么类型就返回什么类型，工厂bean:返回的类型可以不是定义的类型
目前创建项目后文件目录：

导入的jar包五个:

这次下载的是5.2.6版本，用到了四个spring的jar包，是ioc需要的至少四个，直接jar包复制后新建lib文件夹，再粘贴到目录下，再手动添加jar包：

spring的官网地址:
https://repo.spring.io/release/org/springframework/spring/

common-logging-1.1.jar的下载地址：
https://mvnrepository.com/artifact/commons-logging/commons-logging/1.1

各个类中的代码:
Emp.java:

package com.company.bean;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 testt(){System.out.println(ename+" 性别"+gender+" "+dept);}public Dept getDept() {return dept;}
}

Dept.java:

package com.company.bean;public class Dept {private String dname;public void setDname(String dname) {this.dname = dname;}@Overridepublic String toString() {return"部门是：" + dname + '\'';}public String getDname(){return dname;}
}

Userservice.java:

package com.company.service;import com.company.dao.UserDao;
import com.company.dao.UserDaoimp;public class Userservice {//创建userdao类属性private UserDao userdao;public void setUserdao(UserDao userdao) {this.userdao = userdao;}public void add(){System.out.println("servicee add..");userdao.update();}public void setUserDao(UserDaoimp userDao) {this.userdao=userDao;}
}

Testdemo.java:

package com.company.spring5.testdemo;import com.company.bean.Emp;
import com.company.service.Userservice;
import com.company.spring5.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class Testdemo {@Testpublic void testAdd(){ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");Userservice userservice = context.getBean("userservice", Userservice.class);userservice.add();}@Testpublic void testbean2(){ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");Emp emp=context.getBean("emp",Emp.class);emp.testt();}@Testpublic void testbean3(){ApplicationContext context=new ClassPathXmlApplicationContext("bean4.xml");Emp emp=context.getBean("emp",Emp.class);emp.testt();}}

bean2.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.xsd http://www.springframework.org/schema/util https://www.springframework.org/schema/util/spring-util.xsd">
<bean id = "userservice" class="com.company.service.Userservice">
<!--    注入userdao对象，name属性:类里面属性名称-->
<!--    ref属性：创建userdao对象bean标签的id值--><property name="UserDao" ref="userdaoimp"></property>
</bean><bean id = "userdaoimp" class="com.company.dao.UserDaoimp"></bean></beans>

UserDaoimp.java:

package com.company.dao;public class UserDaoimp implements UserDao{@Overridepublic void update() {System.out.println("overider update");}
}

内部bean（嵌套写法)和级联赋值

第一种写法。内部bean
bean3.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.company.bean.Emp"><property name="ename" value="lucy"></property><property name="dept"><bean id="dept" class="com.company.bean.Dept"><property name="dname" value="财务部"></property>
<!--                嵌套写法，在一个bean中嵌套另一个bean--></bean></property><property name="gender" value="女"></property></bean>
</beans>

注入属性–级联赋值

   <bean id="emp" class="com.company.bean.Emp"><property name="ename" value="lucy"></property><property name="dept" ref="dept"></property><property name="gender" value="女"></property>
<!--        级联赋值：通过外部bean的方式引入，给属性赋值--></bean><bean id="dept" class="com.company.bean.Dept"><property name="dname" value="人事部"></property></bean>

结果:

级联赋值的第二种写法。直接在属性中注入：
bean4.xml:

 <bean id="emp" class="com.company.bean.Emp"><property name="ename" value="lucy"></property><property name="dept" ref="dept"></property><property name="dept.dname" value="人事部门之deptname"></property>    <!--这种方法注入属性需要在Ept类中实现对Dept使用getter方法才可以使用--><property name="gender" value="女"></property>
</bean><bean id="dept" class="com.company.bean.Dept"><property name="dname" value="Caiwu"></property></bean>

且在Emp中加上：

public Dept getDept() {return dept;}

结果：

xml注入集合属性

1.注入数组类型

2.注入list集合类型

3.注入map类型属性

创建类，定义不同类型的属性

现在的目录：

Testdemo1.Java

package testdemo;import collection.Stu;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class Testdemo1 {@Testpublic void testvalue(){ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");Stu stu= context.getBean("stu", Stu.class);stu.ontest();}
}

Stu.java:

package collection;import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;public class Stu {private String[] lesson;//属性 课程（有多门课程）public void setLesson(String[] lesson){this.lesson=lesson;}private List<String> newlist;//list类型的属性private Map<String,String> newmap;//Map类型的属性private Set<String>newset;public void setNewlist(List<String> newlist) {this.newlist = newlist;//setter方法}public void setNewset(Set<String> newset) {this.newset = newset;}public void setNewmap(Map<String, String> newmap) {this.newmap = newmap;}public void ontest(){System.out.println(Arrays.toString(lesson));System.out.println(newlist);System.out.println(newmap);System.out.println(newset);}
}

bean1.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="collection.Stu"><property name="lesson" ><array><value>语文</value><value>数学</value><value>english</value></array></property><property name="newlist"><list><value>list1</value><value>list2</value><value>list3</value></list></property><property name="newmap"><map><entry key="张三" value="第一名"></entry><entry key="李四" value="第二名"></entry><entry key="王五" value="第三名"></entry></map></property><property name="newset"><set><value>c语言</value><value>Java</value><value>html</value><value>css</value></set></property>
</bean>
</beans>

结果：

IOC操作工厂bean

第一步：创建类，让这个类作为工厂bean,实现接口factorybean
第二步：实现接口里面的方法，在实现的方法中定义返回的bean类型
先创建一个类:

package factorybean;public class Mybean {@Overridepublic String toString() {return "Mybean{}";}
}

bean2.xml进行配置:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:util="http://www.springframework.org/schema/util"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="mybook" class="factorybean.Mybean"></bean>
</beans>

测试类:

@Testpublic void test2(){ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");Mybean mybook = context.getBean("mybook", Mybean.class);System.out.println(mybook);}

结果:

工厂bean设置返回的bean:


public class Mybean implements FactoryBean<Dept> {@Override//定义返回的beanpublic Dept getObject() throws Exception {Dept dept = new Dept();dept.setDname("财务");return dept;}

测试类:

@Testpublic void test2(){ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");Dept dept = context.getBean("mybook", Dept.class);System.out.println(dept);}

注意这句话 Dept dept = context.getBean(“mybook”, Dept.class);中的"mybook"跟

<bean id="mybook" class="factorybean.Mybean">
</bean>

中的id是对应的关系，否则会报错。
Dept类:

package com.company.bean;public class Dept {private String dname;public void setDname(String dname) {this.dname = dname;}@Overridepublic String toString() {return"部门是：" + dname + '\'';}public String getDname(){return dname;}
}

bean作用域

在spring里面，默认情况下是单实例对象
可以测试：

  @Testpublic void testvalue(){ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");Stu stu= context.getBean("stu", Stu.class);Stu stu2 = context.getBean("stu",Stu.class);stu.ontest();stu2.ontest();}

运行后：

可以发现输出的内容是相同的，如果没有tostring方法，输出的地址是相同的，也可以证明是单实例
singleton单实例 prototype多实例

<bean id="stu" class="collection.Stu" scope="prototype">

设置为多实例对象

bean生命周期

（1）通过构造器创建bean实例（无参数构造),
(2)为bean的属性设置值和对其他bean的引用（调用set方法)
(3)调用bean的初始化方法（需要进行配置）
（4）bean可以使用了（对象获取到了0
(5)当容器关闭的时候，调用bean的销毁方法
代码: 在bean包下创建类:

package com.company.bean;import org.w3c.dom.ls.LSOutput;public class Orders {public Orders() {System.out.println("第一步创建对象");}private String oname;public void setOname(String oname) {this.oname = oname;System.out.println("第二步调用set方法设置属性值");;}public void initmethod(){System.out.println("执行初始化");}public void destroymethod(){System.out.println("执行销毁");}
}

bean3.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="orders" class="com.company.bean.Orders" init-method="initmethod" destroy-method="destroymethod"><property name="oname" value="手机" />
</bean>
</beans>

测试类：

 @Testpublic void test3(){ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");Orders orders = context.getBean("orders", Orders.class);System.out.println("第四步 获取创建bean实例对象");System.out.println(orders);((ClassPathXmlApplicationContext)context).close();}

xml自动装配

什么是自动装配:根据指定装配规则（属性名称或者属性类型），spring自动将匹配的属性值进行注入

<!--实现自动装配
bean标签 autowire属性
配置自动装配autorire属性常用两个值:byNane根据属性名称注入,注入值bean的id值和类属性名称一样
bype根据属性类型注入--><bean id= “emp" class= "com.company.bean. Emp" autowired="byType">.
<!--property name=" dept" ref ="dept"></property>--></bean>
<bean id ="dept"class="com.company.bean.Dept"</bean>

bean管理操作有两种方式：基于xml配置文件实现和基于注解方式实现
引入外部属性文件：

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

第一步引入aop依赖
第二步开启组件扫描
如果扫描多个包，可以多个包用逗号隔开，也可以扫描上层目录

<?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/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd">
<context:component-scan base-package="com"></context:component-scan>
</beans>

四个注解:
1.@Component @Component 是所有受Spring 管理组件的通用形式,@Component注解可以放在类的头上,@Component不推荐使用。
2.@Controller @Controller对应表现层的Bean,.
3.@ Service @Service对应的是业务层Bean
4.@ Repository @Repository对应数据访问层Bean ,
这四个注解功能是一样的都能实现创建bean实例，只是在写代码时为了方便项目管理出于开发习惯才这样区分

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

@Autowired:根据属性类型进行自动装配
@Qualifier:根据属性名称进行注入
@Resource: 可以根据类型注入也可以根据名称注入
@Value: 注入普通类型属性

@servicepublic class UserService{//定义dao类型属性
//不需要添加set方法
//添加注入属性注解@Autowiredprivate UserDao userDao;publie void add(){System.out.printIn("service add.."
);userDao. add();
}

用Autowierd注入属性实例:

先导入aop的jar包
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:p="http://www.springframework.org/schema/p"xmlns:context="http://www.springframework.org/schema/context"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsd
"><context:component-scan base-package="com.company"></context:component-scan>
</beans>

dao层:

package com.company.dao;public interface UserDao {//public void add;public void update();
}package com.company.dao;
import org.springframework.stereotype.Repository;
@Repository
public class UserDaoimp implements UserDao{@Overridepublic void update() {System.out.println("overider update");}
}

service层:

package com.company.service;
import com.company.dao.UserDao;
import com.company.dao.UserDaoimp;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;import javax.annotation.Resource;
@Repository
public class Userservice {//创建userdao类属性@Autowiredprivate UserDao userdao;public void add(){System.out.println("service add");userdao.update();}

测试：

  @Testpublic void Testservice(){ApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");Userservice userservice = context.getBean("userservice",Userservice.class);System.out.println(userservice);userservice.add();}

结果:

value注入实例：

  @Value(value="你好")private String name;public void add(){System.out.println("service add"+name);userdao.update();

再次运行测试类结果：

AOP

Spring MVC是一款优秀的基于MVC思想的应用框架，它是Spring提供的一个实现了Web MVC设计模式的轻量级Web框架。Spring MVC框架主要由DispatcherServlet、处理器映射、控制器、视图解析器、视图组成，总结出Spring MVC的工作流程如下：
（1）客户端请求提交到DispatcherServlet。
（2）由DispatcherServlet控制器寻找一个或多个HandlerMapping，找到处理请求的Controller。
（3）DispatcherServlet将请求提交到Controller。
（4）Controller调用业务逻辑处理后，返回ModelAndView。（5）DispatcherServlet寻找一个或多个ViewResoler视图解析器，找到ModelAndView指定的视图。
（6）视图负责将结果显示到客户端。
patcherServlet将请求分发给Controller之前，需要借助于Spring MVC提供的HandlerMapping定位到具体的Controller。 HandlerMapping接口负责完成客户请求到Controller映射。 Controller接口将处理用户请求，这和Java Servlet扮演的角色是一致的。一旦Controller处理完用户请求，则返回ModelAndView对象给DispatcherServlet前端控制器，ModelAndView中包含了模型（Model）和视图（View）。从宏观角度考虑，DispatcherServlet是整个Web应用的控制器；从微观角度考虑，Controller是单个Http请求处理过程中的控制器，而ModelAndView是Http请求过程中返回的模型（Model）和视图（View）。 ViewResolver接口（视图解析器）在Web应用中负责查找View对象，从而将相应结果渲染给客户。
基于注解的控制器
在使用Spring MVC进行Web应用开发时，**Controller是Web应用的核心。Controller实现类包含了对用户请求的处理逻辑，是用户请求和业务逻辑之间的“桥梁”，**是Spring MVC框架的核心部分，负责具体的业务逻辑处理。
AOP(概念)
1、什么是AOP
(1)面向切面编程(方面),利用AOP可以对业务逻辑的各个部分进行隔离,从而使得
业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率
(2)通俗描述:不通过修改源代码方式,在主千功能里面添加新功能
(3)使用登录例子说明AOP
　Controller注解类型
　在Spring MVC中，使用org.springframework.stereotype.Controller注解类型声明某类的实例是一个控制器

AOP底层使用动态代理
第一种有接口，使用JDK动态代理
1.使用proxy类里面的方法创建代理对象
第二种没有接口，使用CGLIB动态代理

spring项目属性注入和bean管理xml 注入一般属性和集合属性相关推荐

Spring——Bean管理-xml方式进行属性注入
目录一.xml方式创建对象二.xml方式注入属性第①种方式注入:set方法注入第②种方式注入:有参构造函数注入 constructor-arg:通过构造函数注入用name标签属性: 不按照顺 ...
IOC操作Bean管理XML方式（注入集合类型属性）
目录 IOC操作Bean管理XML方式(注入集合类型属性) (1)首先进行环境的搭建和准备 (2)创建一个类:用来完成集合类型属性注入 (3)在Spring 配置文件进行配置 (4)编写一个测试类进行 ...
IOC操作Bean管理XML方式（有参构造注入属性）
IOC操作Bean管理XML方式目录有参构造注入属性 (1)步骤(创建类,定义属性,创建属性对应的有参构造方法): (2)步骤:在Spring 的xml配置文件中进行配置 (3)步骤:进行测试结 ...
IOC操作Bean管理XML方式（外部属性文件）
目录 IOC操作Bean管理XML方式(外部属性文件) 前情引入: 实验演示: 1.直接配置数据库信息 (1)配置德鲁伊连接池 (2)引入德鲁伊连接池jar包 (3)创建一个bean6.xml配置文件 ...
IOC操作Bean管理XML方式（注入空值和特殊符号）
IOC操作Bean管理XML方式(注入空值和特殊符号) 目录 IOC操作Bean管理XML方式(注入空值和特殊符号) (1)通过null标签注入空值: 标签注入空值 (2)属性值中包含特殊符号: 方法 ...
IOC操作Bean管理XML方式（xml自动装配）
目录 IOC操作Bean管理XML方式(xml自动装配) 一.演示自动装配过程 (1)根据属性名称装配步骤一: 步骤二: 步骤三: (2)根据属性类型装配 (2.1)根据类型自动装配产生 ...
IOC操作Bean管理XML方式（bean 的生命周期）
目录 IOC操作Bean管理XML方式(bean 的生命周期) 1.bean 的生命周期(在单例模式下的生命周期) (1)通过构造器创建 bean 的实例(执行类中无参构造方法去创建对象) (2)为 ...
IOC操作Bean管理XML方式（bean的作用域）
目录 IOC操作Bean管理XML方式(bean的作用域) 1.在Spring 里面,设置创建 bean 实例是单实例还是多实例的方式 (1)在Spring 配置文件bean 标签里面有属性(scop ...
IOC操作Bean管理XML方式（FactoryBean）
目录 IOC操作Bean管理XML方式(FactoryBean) Spring 有两种类型的bean 第一种:是普通的 bean 第二种:工厂bean FactoryBean 第一步:创建类,让这个类 ...

spring项目属性注入和bean管理xml 注入一般属性和集合属性

IOC