Spring配置BeanXml文件专题

合集下载

Spring如何在xml文件中配置Bean

Spring如何在xml⽂件中配置BeanSpring容器是⼀个⼤⼯⼚，负责创建、管理所有的Bean。

Spring容器⽀持2种格式的配置⽂件：xml⽂件、properties⽂件，最常⽤的是xml⽂件。

Bean在xml⽂件中的配置<beans>根元素，可包含多个<bean>元素，⼀个<bean>即⼀个Bean的配置。

<bean>⼀个<bean>即⼀个Bean对象。

原来是new出来该类的⼀个对象，Spring中是⼀个<bean>创建⼀个对象。

<bean name="" class="" scope="" />name指定对象的名称，class指定该Bean的类，scope指定该对象的作⽤域。

class属性是必须的，其它可选。

对象的名称可通过name或id指定，id只能指定⼀个名称，name可指定⼀个或多个名称，⽤逗号或分号隔开即可。

⽰例：name="grade,score"。

未指定id或name时，默认取class属性的值。

Bean的作⽤域作⽤域说明singleton（单例）该Bean（类）在Spring容器中只有⼀个实例，⽆论引⽤/获取这个Bean多少次，都指向同⼀个对象。

singleton是Bean的默认作⽤域，适⽤于⽆会话状态的Bean（如Dao组建、Service组件）。

prototype（原型）每次获取该Bean时，都会创建⼀个新的实例。

request在⼀次HTTP请求中，获取的是该Bean的同⼀个实例，该实例只在此次HTTP请求中有效。

对于不同的HTTP请求，会创建不同的实例。

session在⼀次HTTP session中获取的是该Bean的同⼀个实例，该实例只在本次HTTP session中有效。

globalSession在⼀个全局的HTTP session中，获取到的是该Bean的同⼀个实例。

Spring装配Bean---使用xml配置

Spring装配Bean---使⽤xml配置声明BeanSpring配置⽂件的根元素是<beans>.在<beans>元素内，你可以放所有的Spring配置信息，包括<bean>元素的声明.除了Beans命名空间，Spring的核⼼框架总共⾃带了10个命名空间配置：命名空间⽤途aop为声明切⾯以及将@AspectJ注解的类代理为Spring切⾯提供了配置元素beans⽀持声明Bean和装配Bean，是Spring最核⼼也是最原始的命名空间context为配置Spring应⽤上下⽂提供了配置元素，包括⾃动检测和装配Bean,注⼊⾮Spring直接管理的对象jee 提供了与Java EE API的集成，例如JNDI和EJBjms为声明消息驱动的POJO提供了配置元素lang ⽀持配置由Groovy、JRuby、BeanShell等脚本实现的Beanmvc启⽤SpringMVC的能⼒，例如⾯向注解的控制器、视图控制器和拦截器oxm ⽀持Spring的对象到xml配置的映射tx 提供声明式事物配置util提供各种各样的⼯具类元素，包括把集合配置为Bean，⽀持属性占位符元素xml结构如下：<?xml version="1.0" encoding="UTF-8" ?><beans xmlns="/schema/beans"xmlns:p="/schema/p"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-4.0.xsd"><bean id="" class="">......</bean><bean id="" class="">......</bean></beans>基于构造函数注⼊使⽤<constructor-arg>元素。

IOC——Spring的bean的管理（xml配置文件）

IOC——Spring的bean的管理（xml配置⽂件）Bean实例化（三种⽅式） 1、使⽤类的⽆参构造进⾏创建（⼤多数情况下） <bean id="user" class="er"></bean> （1）上⾯的代码使⽤的就是默认的⽆参构造的⽅式进⾏Bean的实例化（2）使⽤这种⽅法我们需要注意，如果类中没有⽆参构造，会出现异常 2、使⽤静态⼯⼚创建（1）创建静态的⽅法，返回类的对象，以User对象为例 public class UserFactory { // 静态⽅法，返回User对象 public static User getUser() { return new User(); } } （2）配置⽂件中使⽤静态⼯⼚创建对象<bean id="user" class="erFactory" factory-method="getUser"></bean> 3、使⽤实例⼯⼚创建（1）创建普通⽅法，返回类的对象，以User对象为例public class UserFactory {// 普通⽅法，返回User对象public User getUser() {return new User();}} （2）配置⽂件中使⽤实例⼯⼚创建对象<bean id="userFactory" class="erFactory"></bean><bean id="user" class="er" factory-bean="userFactory" factory-method="getUser"></bean>Bean标签的常⽤属性 1、id属性给当前bean起名称，不能包含特殊符号，我们可以根据id值得到配置对象. 2、class属性给当前bean指定对象所在类的全路径. 3、name属性给当前bean起名称（与id属性类似），但是id属性值不能包含特殊符号，⽽在name属性值⾥⾯可以包含特殊符号。

Spring中注解配置与xml配置分析

虽然 2.0 版本发布以来，Spring 陆续提供了十多个注解，但是提供的这些注解只是为了在某些情况下简化 XML 的配置，并非要取代 XML 配置方式。这一点可以从 Spring IoC 容器的初始化类可以看出：ApplicationContext 接口的最常用的实现类是 ClassPathXmlApplicationContext 和 FileSystemXmlApplicationContext，以及面向 Portlet 的 XmlPortletApplicationContext 和面向 web 的 XmlWebApplicationContext，它们都是面向 XML 的。Spring 3.0 新增了另外两个实现类：AnnotationConfigApplicationContext 和 AnnotationConfigWebApplicationContext。从名字便可以看出，它们是为注解而生，直接依赖于注解作为容器配置信息来源的 IoC 容器初始化类。由于 AnnotationConfigWebApplicationContext 是 AnnotationConfigApplicationContext 的 web 版本，其用法与后者相比几乎没有什么差别
也可以单独显式地来启用某个注解处理器，而且可以给处理器添加拦截器：
<be.factory.annotation.AutowiredAnnotationBeanPostProcessor"/>
<bean class="monAnnotationBeanPostProcessor"/>
<mvc:annotation-driven />
当然了也可以使用如下的方式显式地加载：

Spring中加载xml配置文件的几种方式

项目中一个需求就是所有的功能都是插件的形式装入系统，这就需要利用Spring去动态加载某一位置下的配置文件，就总结了下Spring中加载xml配置文件的方式, xml是最常见的spring 应用系统配置源。

Spring中的几种容器都支持使用xml装配bean，包括：XmlBeanFactory,ClassPathXmlApplicationContext,FileSystemXmlApplicationContext,XmlWebApplicationContext,.....一: XmlBeanFactory 引用资源1.Resource cr = new ClassPathResource("applicationContext.xml");BeanFactory bf=new XmlBeanFactory(cr);UserDao userDao = (UserDao)bf.getBean("userDao");二: ClassPathXmlApplicationContext 编译路径使用ClassPathXmlApplicationContext对象获取，必须把applicationContext.xml放置到类的加载路径中，也就是Src下面1.ApplicationContext factory=new ClassPathXmlApplicationContext("classpath:appcontext.xml");// src目录下的2.ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); UserDao userDao = (UserDao)context.getBean("userDao");3.ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext-oracle.xml","applicationContext.xml"});UserDao userDao = (UserDao)context.getBean("userDao");// src/conf 目录下的4.ApplicationContext factory=new ClassPathXmlApplicationContext("conf/appcontext.xml");5.ApplicationContext factory=new ClassPathXmlApplicationContext("file:G:/Test/src/appcontext.xml");三: FileSystemXmlApplicationContext用文件系统的路径必须把applicationContext.xml放置到工程目录下面，也就是项目路径的下面1.ApplicationContext factory=newFileSystemXmlApplicationContext("src/appcontext.xml");//使用了classpath: 前缀,作为标志, 这样,FileSystemXmlApplicationContext 也能够读入classpath下的相对路径没有classpath的话就是从当前的工作目录2.ApplicationContext factory=newFileSystemXmlApplicationContext("classpath:appcontext.xml");3.ApplicationContext factory=newFileSystemXmlApplicationContext("file:G:/Test/src/appcontext.xml");4.ApplicationContext factory=newFileSystemXmlApplicationContext("G:/Test/src/appcontext.xml");四: XmlWebApplicationContext是专为Web工程定制的。

spring中bean配置和bean注入

spring中bean配置和bean注⼊1 bean与spring容器的关系Bean配置信息定义了Bean的实现及依赖关系，Spring容器根据各种形式的Bean配置信息在容器内部建⽴Bean定义注册表，然后根据注册表加载、实例化Bean，并建⽴Bean和Bean的依赖关系，最后将这些准备就绪的Bean放到Bean缓存池中，以供外层的应⽤程序进⾏调⽤。

1 bean配置bean配置有三种⽅法：基于xml配置Bean使⽤注解定义Bean基于java类提供Bean定义信息1.1 基于xml配置Bean对于基于XML的配置，Spring 2.0以后使⽤Schema的格式，使得不同类型的配置拥有了⾃⼰的命名空间，是配置⽂件更具扩展性。

①默认命名空间：它没有空间名，⽤于Spring Bean的定义；②xsi命名空间：这个命名空间⽤于为每个⽂档中命名空间指定相应的Schema样式⽂件，是标准组织定义的标准命名空间；③aop命名空间：这个命名空间是Spring配置AOP的命名空间，是⽤户⾃定义的命名空间。

命名空间的定义分为两个步骤：第⼀步指定命名空间的名称；第⼆步指定命名空间的Schema⽂档样式⽂件的位置，⽤空格或回车换⾏进⾏分分隔。

1.1.1 Bean基本配置在Spring容器的配置⽂件中定义⼀个简要Bean的配置⽚段如下所⽰：⼀般情况下，Spring IOC容器中的⼀个Bean即对应配置⽂件中的⼀个<bean>,这种镜像对应关系应该容易理解。

其中id为这个Bean的名称，通过容器的getBean("foo")即可获取对应的Bean，在容器中起到定位查找的作⽤，是外部程序和Spring IOC容器进⾏交互的桥梁。

class属性指定了Bean对应的实现类。

下⾯是基于XML的配置⽂件定义了两个简单的Bean：<?xml version="1.0" encoding="UTF-8" ?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd"><bean id="car" name="#car1" class="com.baobaotao.simple.Car"></bean><bean id="boss" class="com.baobaotao.simple.Boss"></bean></beans>1.1.2 依赖注⼊1. 属性注⼊2. 构造函数注⼊3. ⼯⼚⽅式注⼊1.2 使⽤注解定义Bean我们知道，Spring容器成功启动的三⼤要件分别是：Bean定义信息、Bean实现类以及Spring本⾝。

Spring中xml的配置

Spring中xml的配置（摘抄）出自：1、value元素<value/>元素通过字符串来指定属性或构造器参数的值。

<bean id="myDataSource" detroy-method="close"class="mons.dbcp.BasicDataSource"><property name="driverClassName"><value>com.mysql.jdbc.Driver</value></proerpty><property name="url"><value>jdbc:mysql://localhost:3306/mydb</value></property><property name="username"><vlaue>root</value></property></bean>2、idref元素idref元素用来将容器内其它bean的id传给<constructor-arg/>或<property/>元素，同时提供错误难功能。

<bean id="theTargetBean" class="..."/><bean id="theClientBean" class="..."><property name="targetName"><idref bean="theTargetBean" /></property></bean>等同于:<bean id="theTargetBean" class="..." /><bean id="theClientBean" class="..."><property name="targetName"><value>theTargetBean</value></bean>使用idref标记允许容器在部署时验证所被引用的bean是否存在。

Spring系列：xml中bean定义详解（-）

Spring系列：xml中bean定义详解（-）======================================================================================================================================================== bean概念回顾我们再来回顾⼀下，被spring管理的对象统称为bean，我们程序中需要⽤到很多对象，我们将这些对象让spring去帮我们创建和管理，我们可以通过bean xml配置⽂件告诉spring容器需要管理哪些bean，spring帮我们创建和组装好这些bean对象；那么我们如何从spring中获取想要的bean对象呢，我们需要给bean定义⼀个名称，spring内部将这些名称和具体的bean对象进⾏绑定，然后spring容器可以通过这个的名称找对我们需要的对象，这个名称叫做bean的名称，在⼀个spring容器中需要是唯⼀的。

bean xml配置⽂件格式bean xml⽂件⽤于定义spring容器需要管理的bean，常见的格式如下：bean元素⽤来定义⼀个bean对象。

格式<bean id="bean唯⼀标识" name="bean名称" class="完整类型名称" factory-bean="⼯⼚bean名称" factory-method="⼯⼚⽅法"/>bean名称每个bean都有⼀个名称，叫做bean名称，bean名称在⼀个spring容器中必须唯⼀，否则会报错，通过bean名称可以从spring容器获取对应的bean对象。

bean别名先来说⼀下什么是别名？相当于⼈的外号⼀样，⼀个⼈可能有很多外号，当别⼈喊这个⼈的名称或者外号的时候，都可以找到这个⼈。

SpringApplicationContext.xml配置的12个技巧和Bean属性说明

SpringApplicationContext.xml配置的12个技巧和Bean属性说明Spring ApplicationContext.xml配置的12个技巧Spring是一个强有力的java程序框架，其被广泛应用于java的程序中。

它用POJO提供了企业级服务。

Spring利用依赖注入可以获得简单而有效的测试能力。

Spring beans，依赖关系，以及服务所需要的bean都将在配置文件中予以描述，配置文件一般采用XML格式。

然而XML配置文件冗长而不易使用，在你进行一个使用了大量bean 的大项目中它将变得难以阅读和控制。

在这篇文章中我将给你展示12种的有关Spring XML配置文件的最佳技巧。

它们中的一些具有更多的实际意义，而不仅是最好的技巧。

请注意另外一些因素，例如域模型的设计，会影响到XML配置，但是这篇文章更关注于XML配置的可读性和可操控性。

1．避免使用自动装配Spring 可以通过bean类的自省来实现自动装配依赖，这样的话你就不必明确地描述bean的属性或者构造函数的参数。

根据属性名称活匹配类型，bean属性可以自动进行装配。

而构造函数可以根据匹配类型自动装配。

你甚至可以设置自动装配进行自动侦测，这样Spring 替你就会选择一个合适的机制。

请看下面的例子：Spring 可以通过bean类的自省来实现自动装配依赖，这样的话你就不必明确地描述bean的属性或者构造函数的参数。

根据属性名称活匹配类型，bean属性可以自动进行装配。

而构造函数可以根据匹配类型自动装配。

你甚至可以设置自动装配进行自动侦测，这样Spring 替你就会选择一个合适的机制。

请看下面的例子：class="com.lizjason.spring.OrderService"autowire="byName"/>OrderService 类的属性名被用来和容器中的一个bean实例进行匹配。

springMVC配置（XML配置详解）

springMVC配置（XML配置详解）原⽂出⾃：web.xml配置：servlet><servlet-name>dispatcher</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><description>加载/WEB-INF/spring-mvc/⽬录下的所有XML作为Spring MVC的配置⽂件</description><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/spring-mvc/*.xml</param-value></init-param><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>dispatcher</servlet-name><url-pattern>*.htm</url-pattern></servlet-mapping>这样，所有的.htm的请求，都会被DispatcherServlet处理；初始化 DispatcherServlet 时，该框架在 web 应⽤程序WEB-INF ⽬录中寻找⼀个名为[servlet-名称]-servlet.xml的⽂件，并在那⾥定义相关的Beans，重写在全局中定义的任何Beans，像上⾯的web.xml中的代码，对应的是dispatcher-servlet.xml；当然也可以使⽤<init-param>元素，⼿动指定配置⽂件的路径；dispatcher-servlet.xml 配置：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:mvc="/schema/mvc"xmlns:p="/schema/p"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd/schema/aop/schema/aop/spring-aop-3.0.xsd/schema/tx/schema/tx/spring-tx-3.0.xsd/schema/mvc/schema/mvc/spring-mvc-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd"><context:component-scan base-package="com.minx.crm.web.controller"/><bean id="viewResolver"class="org.springframework.web.servlet.view.InternalResourceViewResolver"p:prefix="/WEB-INF/jsp/"p:suffix=".jsp" /></beans>第⼀个Controller：package com.minx.crm.web.controller;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;@Controllerpublic class IndexController {@RequestMapping("/index")public String index() {return "index";}}@Controller注解标识⼀个控制器，@RequestMapping注解标记⼀个访问的路径（/index.htm），return "index"标记返回视图（index.jsp）；注：如果@RequestMapping注解在类级别上，则表⽰⼀相对路径，在⽅法级别上，则标记访问的路径；从@RequestMapping注解标记的访问路径中获取参数：Spring MVC ⽀持RESTful风格的URL参数，如：@Controllerpublic class IndexController {@RequestMapping("/index/{username}")public String index(@PathVariable("username") String username) {System.out.print(username);return "index";}}在@RequestMapping中定义访问页⾯的URL模版，使⽤{}传⼊页⾯参数，使⽤@PathVariable 获取传⼊参数，即可通过地址：http://localhost:8080/crm/index/tanqimin.htm 访问；根据不同的Web请求⽅法，映射到不同的处理⽅法：使⽤登陆页⾯作⽰例，定义两个⽅法分辨对使⽤GET请求和使⽤POST请求访问login.htm时的响应。

Spring学习之xml配置Bean总结

Spring学习之xml配置Bean总结本篇⽂章已重新总结到新博客，欢迎访问：学习Spring时，我⽤的是Maven来管理jar包，先看看maven的pom.xml：pom.xml1<project xmlns="/POM/4.0.0" xmlns:xsi="/2001/XMLSchema-instance"2 xsi:schemaLocation="/POM/4.0.0 /maven-v4_0_0.xsd">3<modelVersion>4.0.0</modelVersion>4<groupId>spring</groupId>5<artifactId>spring_TencentKe_Tonggang-5</artifactId>6<packaging>war</packaging>7<version>1.4</version>8<name>spring_TencentKe_Tonggang-5 Maven Webapp</name>9<url></url>10<dependencies>11<dependency>12<groupId>junit</groupId>13<artifactId>junit</artifactId>14<version>3.8.1</version>15<scope>test</scope>16</dependency>1718<dependency>19<groupId>org.springframework</groupId>20<artifactId>spring-core</artifactId>21<version>4.3.7.RELEASE</version>22</dependency>2324<dependency>25<groupId>org.springframework</groupId>26<artifactId>spring-context</artifactId>27<version>4.3.7.RELEASE</version>28</dependency>2930<dependency>31<groupId>org.springframework</groupId>32<artifactId>spring-beans</artifactId>33<version>4.3.7.RELEASE</version>34</dependency>3536<dependency>37<groupId>c3p0</groupId>38<artifactId>c3p0</artifactId>39<version>0.9.1.2</version>40</dependency>4142<dependency>43<groupId>mysql</groupId>44<artifactId>mysql-connector-java</artifactId>45<version>5.1.38</version>46</dependency>474849<dependency>50<groupId>org.aspectj</groupId>51<artifactId>aspectjweaver</artifactId>52<version>1.8.9</version>53</dependency>5455<dependency>56<groupId>org.springframework</groupId>57<artifactId>spring-jdbc</artifactId>58<version>4.3.7.RELEASE</version>59</dependency>60</dependencies>61<build>62<finalName>spring_TencentKe_Tonggang-5</finalName>63</build>64</project>先看看写的三个bean:Car.java:package spring.beans;public class Car {private String cname;//车名字private int price;//价格private double max;//最⼤速度public Car() {super();// TODO Auto-generated constructor stub}public Car(String cname, double max) {super();ame = cname;this.max = max;}public Car(String cname, int price) {super();ame = cname;this.price = price;}public void setCname(String cname) {ame = cname;}public void setPrice(int price) {this.price = price;}@Overridepublic String toString() {return "Car [cname=" + cname + ", price=" + price + ", max=" + max + "]";}}Person.java:package spring.beans;import java.util.List;import java.util.Map;public class Person {private String Pname;//姓名private int age;//年龄private Car car;//⼀辆车private List<Car> cars;//很多车private Map<String, String> des;//描述public Person() {}public void setDes(Map<String, String> des) {this.des = des;}public void setCars(List<Car> cars) {this.cars = cars;}public void setPname(String pname) {Pname = pname;}public void setAge(int age) {this.age = age;}public void setCar(Car car) {this.car = car;}@Overridepublic String toString() {return "Person [Pname=" + Pname + ", age=" + age + ", car=" + car + ", cars=" + cars + ", des=" + des + "]"; }}Person1.java:package spring.beans;import java.util.List;public class Person1 {private String pname;private int age;private List<Car> cars;public void setPname(String pname) {this.pname = pname;}public void setAge(int age) {this.age = age;}public void setCars(List<Car> cars) {this.cars = cars;}@Overridepublic String toString() {return "Person1 [pname=" + pname + ", age=" + age + ", list=" + cars + "]";}}xml配置中，看下⾯xml⽂件配置：applicationContext.xml:<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xmlns:context="/schema/context"xmlns:util="/schema/util"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-4.1.xsd /schema/context /schema/context/spring-context-4.3.xsd/schema/util /schema/util/spring-util-4.3.xsd"><bean id="person" class="spring.beans.Person"><property name="pname" value="张三"></property><property name="age" value="20"></property><property name="cars"><list><ref bean="car1"/><ref bean="car2"/></list></property><property name="des"><map><entry key="a" value="a1"></entry><entry key="b" value="b1"></entry></map></property></bean><util:list id="cars"><ref bean="car1"/><ref bean="car2"/></util:list><bean id="person1" class="spring.beans.Person1" p:pname="王五" p:age="23"p:cars-ref="cars"></bean><bean id="car1" class="spring.beans.Car"><property name="cname" value="奥迪"></property><property name="price" value="300000"></property></bean><bean id="car2" class="spring.beans.Car"><property name="cname" value="长安"></property><property name="price" value="100000"></property></bean></beans>测试：package spring.beans.test;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;import spring.beans.Person;import spring.beans.Person1;public class Main {public static void main(String[] args) {ApplicationContext cxt= new ClassPathXmlApplicationContext("applicationContext.xml");Person p=(Person) cxt.getBean("person");System.out.println(p);Person1 p1=(Person1) cxt.getBean("person1");System.out.println(p1);}}输出：Person [Pname=张三, age=20, car=null, cars=[Car [cname=奥迪, price=300000, max=0.0], Car [cname=长安, price=100000, max=0.0]], des={a=a1, b=b1}] Person1 [pname=王五, age=23, list=[Car [cname=奥迪, price=300000, max=0.0], Car [cname=长安, price=100000, max=0.0]]]。

spring中读取xml配置文件、获取bean

读取xml文件/*** 利用XmlBeanFactory(Resource resource)* 这里Resource必须是xml格式* Resource包括：AbstractResource, ClassPathResource, FileSystemResource, * InputStreamResource, ServletContextResource, UrlResource*//** 利用InputStreamResource(InputStream inputStream)* 要将applicationContext.xml放在项目根目录下*/InputStream is = null;try {is = new FileInputStream("applicationContext.xml");} catch (FileNotFoundException e) {e.printStackTrace();}Resource resource = new InputStreamResource(is);BeanFactory factory = new XmlBeanFactory(resource);UserDao userDao = (UserDao)factory.getBean("userDao");/** 利用Properties* 要将bean.properties放在类路径－－源文件夹（src）目录下*/具体见1.利用ClassPathXmlApplicationContext可以从classpath中读取XML文件(1) ApplicationContext context = newClassPathXmlApplicationContext("applicationContext.xml");UserDao userDao = (UserDao)context.getBean("userDao");(2) ClassPathXmlApplicationContext resource = new ClassPathXmlApplicationContext(new String[]{"applicationContext-ibatis-oracle.xml","applicationC ontext.xml","applicationContext-data-oracle.xml"});BeanFactory factory = resource;UserDao userDao = (UserDao) factory.getBean("userDao");2. 利用ClassPathResource可以从classpath中读取XML文件Resource cr = new ClassPathResource("applicationContext.xml");BeanFactory bf=new XmlBeanFactory(cr);UserDao userDao = (UserDao)bf.getBean("userDao");加载一个xml文件org.spring framewonfig.PropertyPlaceholderConfigurer不起作用3．利用XmlWebApplicationContext读取从Web应用程序的文件架构中，指定相对位置来读取定义文件。

Spring详解（八）----SpringBean的装配（基于注解的方式【推荐】）

Spring详解（⼋）----SpringBean的装配（基于注解的⽅式【推荐】）1通过前⾯的学习，我们已经知道如何通过XML的⽅式去装配Bean了，但是我们在实际的开发中，为了简化开发，更多的时候会使⽤到注解（annotation）的⽅式来装配Bean。

因为注解可以⼤量减少繁琐的XML配置，并且注解的功能更为强⼤，它既能实现XML的功能，也提供了⾃动装配的功能，更加有利于开发，这就是“约定优于配置”原则，简称CoC(Convention over Configuration)。

Spring提供了两种⽅式让Spring IOC容器发现Bean：组件扫描：通过定义资源的⽅式，让Spring IOC容器扫描资源所在的包，从⽽装配Bean。

⾃动装配：通过注解⾃动找到依赖关系中所需要的Bean。

所以在后⾯的学习中都会以注解为主，注意这⾥只是主，⽽不是全部以注解的⽅式去实现。

因为在实际的开发中是不会全部使⽤注解去开发，都是两种⽅式结合，⼀般使⽤XML注册Bean，⽐如加载数据库的连接⽂件时，⼀般会在XML中配置，因为这些公共配置⽂件使⽤注解配置会很分散，也不⽅便更改维护，不便于统⼀管理。

⽽属性的注⼊都使⽤注解，所以是以注解为主，以XML为辅。

本章先来总结⼀下组件扫描⽅式，然后下⼀篇⽂章总结使⽤注解进⾏⾃动装配。

2我们来看之前的User类，并⽤@Component进⾏装配：/*** ⽤户实体类*/@Component(value = "user")public class User {@Value(value = "2020")private int userId;@Value(value = "是菜逼唐")private String userName;@Value(value = "20")private int userAge;@Value(value = "123456")private String userPwd;@Value(value = "地球中国北京")private String userAddress;//⼥朋友(装配对象这⾥下⼀章介绍--使⽤注解⾃动装配)private GirlFriend girlFriend;//getter、setter、toString⽅法省略......}下⾯来介绍⼀下@Component和@Value注解：@Component：相当于<bean id="" class=""/>，这个注解表⽰Spring 容器会把这个类扫描成⼀个Bean实例，其中value属性代表这个类在Spring 中的id，相当于XML⽅式中定义的Bean 的id ：<bean id="user" class="er">，我们也可以直接简写成@Component("user")，甚⾄直接写成@Component，如果不写的话，默认以类名的⾸字母⼩写的形式作为id 配置到容器中。

springMVC配置文件详解

web.xml的配置web.xml应该是整个项目最重要的配置文件了，不过servlet3.0中已经支持注解配置方式了。

在servlet3.0以前每个servlet必须要在web.xml中配置servlet及其映射关系。

但是在spring框架中就不用了，因为Spring中是依赖注入（Dependency Injection）的也叫控制反转（Inversion of Control）。

但是也要配置一个重要的servlet，就是前端控制器（DispatcherServlet）。

配置方式与普通的servlet基本相似。

配置内容如下：<servlet><servlet-name>spring</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>WEB-INF/classes/spring/springmvc.xml</param-value></init-param></servlet><servlet-mapping><servlet-name>spring</servlet-name><url-pattern>/</url-pattern></servlet-mapping>这里需要注意，springmvc.xml是spring配置文件，将在后面讨论。

spring介绍基于xml配置Bean

spring介绍基于xml配置Beanspring介绍 spring是⼀个轻量级的开源框架(轻量级-指消耗资源少，开发过程快捷⽅便) ⽅便解耦，简化开发 Spring就是⼀个⼤⼯⼚，可以将所有对象创建和依赖的关系维护，交给Spring管理。

--重点了解 AOP编程的⽀持 Spring提供⾯向切⾯编程，可以⽅便的实现对程序进⾏权限拦截、运⾏监控等功能。

声明式事务的⽀持只需要通过配置就可以完成对事务的管理，⽽⽆需⼿动编程。

⽅便程序的测试 Spring对Junit4⽀持，可以通过注解⽅便的测试Spring程序。

⽅便集成各种优秀框架 Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架的直接⽀持（如：Struts、Hibernate、MyBatis等）。

降低JavaEE API的使⽤难度 Spring对JavaEE开发中⾮常难⽤的⼀些API（JDBC、JavaMail、远程调⽤等），都提供了封装，使这些API应⽤难度⼤⼤降低。

spring体系spring⼤致分为5个模块:Test、AOP、web数据访问、集成部分(Data Access/Integration)、核⼼容器(Core Container)bean、core、context可以说是spring的三⼤核⼼组件这⾥详细的介绍下： spring-core：依赖注⼊IoC与DI的最基本实现 spring-beans：Bean⼯⼚与bean的装配 spring-context：spring的context上下⽂即IoC容器 spring-expression：spring表达式语⾔盗⼀张别⼈总结的依赖关系图所以当我们创建完spring项⽬后,pom.xml⽂件中⾃动添加了spring-context后，这样依赖的core、beans等jar包就全部导⼊了<dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>${spring.framework.version}</version></dependency>后续补充底层的实现原理Spring最⼤的特性应该就是控制反转和依赖注⼊了看了不下⼗⼏个对于这两个名词的解释，这⾥⽤⾃⼰的话概括下控制反转:就是把创建对象的权利从⾃⼰交给外部的容器，不再由⾃⼰创建，控制权发⽣了改变依赖注⼊:当运⾏⼀个A类需要依赖另⼀个B类的对象时，不需要⾃⼰new对象，⽽是通过容器控制程序创建对象B并注⼊到A⾥⾯下⾯⽤xml配置的⽅式巩固对这两种设计的理解基于xml配置Bean这⾥先介绍下标签的基本含义 bean-定义⼀个Bean实例的信息通俗的讲就是⼀个对象 bean属性: id 指定⽣成的Bean实例名称 name 指定⽣成的Bean实例名称 scope 设定Bean实例的⽣成⽅式默认是singleton模式还有prototype多例模式 request、session、global session模式 init-method 初始化时调⽤的⽅法⽐如对象中含有a⽅法，可以配置此属性这样每次⽣成对象时都会调⽤a⽅法 destroy-method 属性实例销毁时要调⽤的⽅法同init-method 但是需要scope设置成singleton模式 bean⼦标签 property 官⽅的话术是⽤来配置Bean实例的依赖关系（set⽅式注⼊，属性⼀定要有set⽅法)，通俗讲就是配置对象属性的值 constructor-arg ⽤来配置Bean实例的依赖关系(构造⽅式注⼊） ref constructor-arg、property、list、set、entry等标记的⼦标记，指定⼀个Bean实例 value constructor-arg、property、list、set、entry等标记的⼦标记，指定⼀个常量 list ⽤以封装List或数组类型属性的依赖注⼊具体的元素通过ref或value⼦标记指定 set 封装Set类型属性的依赖注⼊具体的元素通过ref或value⼦标记指定 map 封装Map类型属性的依赖注⼊应为map是键值对，需要⽤entry⼦标签设置“键/值”对了解了标签基本的含义，现在实际操作下，先新建⼀个spring⼯程、在ioc的包下创建测试类User、Car;在resources下创建Spring Bean Configuration file模板的ioctest.xml⽂件<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd"></beans>package ioc;import org.springframework.beans.factory.annotation.Value;import ponent;public class Car {private String name;private double price;public Car() {}public Car(String name, double price) {super(); = name;this.price = price;}public String getName() {return name;}public void setName(String name) { = name;}public double getPrice() {return price;}public void setPrice(double price) {this.price = price;}@Overridepublic String toString() {return "Car [name=" + name + ", price=" + price + "]";}}User类，写的挺多，⼤部分都是set、get⽅法package ioc;import java.util.List;import java.util.Map;import java.util.Set;public class User {private String name;private int age;private String sex;private Car car;private List<Integer> intlist;private List<Car> carList;private Set<Car> carSet;private Map<Integer, Car> carMap;//默认构造⽅法public User() {}// 有参构造⽅法public User(String name, Car car, List<Car> carList) { super(); = name;this.car = car;this.carList = carList;}public List<Integer> getIntlist() {return intlist;}public void setIntlist(List<Integer> intlist) {this.intlist = intlist;}public String getName() {return name;}public void setName(String name) { = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}public Car getCar() {return car;}public void setCar(Car car) {this.car = car;}public List<Car> getCarList() {return carList;}public void setCarList(List<Car> carList) {this.carList = carList;}public Set<Car> getCarSet() {return carSet;}public void setCarSet(Set<Car> carSet) {this.carSet = carSet;}public Map<Integer, Car> getCarMap() {return carMap;}public void setCarMap(Map<Integer, Car> carMap) {this.carMap = carMap;}@Overridepublic String toString() {return "User [name=" + name + ", age=" + age + ", sex=" + sex + ", car=" + car + ", carList=" + carList+ ", carSet=" + carSet + ", carMap=" + carMap + "]";};public void init() {System.out.println("开始调⽤");}public void destroy() {System.out.println("结束调⽤");}}<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd"> <bean name="user" class="er" scope="prototype"init-method="init" destroy-method="destroy"><constructor-arg name="name" value="张三"></constructor-arg><constructor-arg name="car" ref="car1"></constructor-arg><constructor-arg name="carList"><list><bean id="car2" class="ioc.Car"><property name="name" value="奔驰"></property><property name="price" value="1000000"></property></bean></list></constructor-arg><property name="age" value="18"></property></bean><bean name="user2" class="er" init-method="init"destroy-method="destroy"><property name="age" value="28"></property><property name="name" value="王⽼五"></property><property name="carSet"><set><ref bean="car1"/><ref bean="car3"/></set></property><property name="carMap"><map><entry key="1"><ref bean="car1"></ref></entry><entry key="2"><ref bean="car1"></ref></entry></map></property></bean><bean id="car1" class="ioc.Car"><property name="name" value="宝马"></property><property name="price" value="500000"></property></bean><bean id="car3" class="ioc.Car"><property name="name" value="特斯拉"></property><property name="price" value="700000"></property></bean></beans>重新配置xml⽂件后，写test类验证package ioc;import org.springframework.context.ApplicationContext;import org.springframework.context.support.ClassPathXmlApplicationContext;public class TestMain {public static void main(String[] args) {//获取容器对象ApplicationContext ac=new ClassPathXmlApplicationContext("ioctest.xml");//通过容器获取配置的javabeanUser user=(User)ac.getBean("user");System.out.println(user);User user2=(User)ac.getBean("user2");System.out.println(user2);}}。

Spring解密之XML解析与Bean注册示例详解

Spring解密之XML解析与Bean注册⽰例详解为什么开始看spring的源码半路转⾏写代码快⼀年半了,从开始⼯作就在使⽤spring框架,虽然会⽤,会搭框架,但是很多时候不懂背后的原理,⽐如:spring是怎样控制事务的,springmvc是怎样处理请求的,aop是如何实现的...这让⼈感觉⾮常不踏实,那就开始慢慢边看书边研究spring的源码吧怎样⾼效的看源码我的答案是带着具体的问题去看源码,不然⾮常容易陷⼊源码细节中不能⾃拔,然后就晕了,最后你发现这看了半天看的是啥玩意啊.引⾔Spring是⼀个开源的设计层⾯框架，解决了业务逻辑层和其他各层的松耦合问题，将⾯向接⼝的编程思想贯穿整个系统应⽤，同时它也是Java⼯作中必备技能之⼀…由于记录的是Spring源码分析的过程，详细⽤法就不⼀⼀赘述了核⼼代码<dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.0.2.RELEASE</version></dependency>⽤法public class Application {public static void main(String[] args) {BeanDefinitionRegistry beanFactory = new DefaultListableBeanFactory();XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);ClassPathResource resource = new ClassPathResource("bean.xml");//整个资源加载的切⼊点。

Spring中Bean的配置：基于XML文件的方式

Spring中Bean的配置：基于XML⽂件的⽅式Bean的配置⼀共有两种⽅式：⼀种是基于XML⽂件的⽅式，另⼀种是基于注解的⽅式。

本⽂主要介绍基于XML⽂件的⽅式<bean id="helloWorld" class="com.sevenhu.domain.HelloWorld"><property name="userName" value="Spring"></property></bean>上⾯的配置代码中：id：Bean的名称，在IOC容器中必须是唯⼀的，若id，没有指定，那么Spring⾃动将类名作为Bean的名字，id可以指定多个名字，名字之间可⽤逗号，分号，或空格分隔。

Spring容器在Spring IOC容器读取Bean配置创建Bean实例之前，必须对它进⾏实例化，只有在容器实例化之后，才可以从IOC容器⾥获取Bean的实例并使⽤。

Spring提供了两种类型的IOC容器实现-BeanFactory：Ioc容器的基本实现。

-ApplicationContext：提供了更多的⾼级特性。

是BeanFactory的⼦接⼝。

-BeanFactory是Spring框架的基础设施，⾯向Spring本⾝；ApplicationContext⾯向使⽤Spring框架的开发者。

ApplicationContext主要有两个实现类：-ClassPathXmlApplicationContext:从类路径下加载配置⽂件。

-FileSystemXmlApplicationContext:从⽂件系统中加载配置⽂件。

ApplicationContext在初始化上下⽂时就实例化所有单例的bean。

属性注⼊：即通过setter⽅法注⼊bean的属性值或依赖的对象。

属性注⼊使⽤<property>元素，使⽤name属性值指定bean的属性名称，value属性指定属性值。

Spring装配Bean教程之XML安装配置bean详解

Spring装配Bean教程之XML安装配置bean详解前⾔众所周知在Spring刚出现的时候，XML是描述配置的主要⽅式，在Spring的名义下，我们创建了⽆数⾏XML代码。

在⼀定程度上，Spring成为了XML的同义词。

现在随着强⼤的⾃动化配置和Java代码的配置出现，XML不再是唯⼀选择，也不应该是⾸选，学习XML配置，更多⽤于维护已有的XML的配置。

下⾯话不多说了，来⼀起看看详细的介绍吧。

创建XML配置规范在使⽤XML配置前，需要创建⼀个新的配置规范，就像JavaConfig需要我们创建带有 @Configuration注解的类，⽽在XML配置中，需要创建⼀个新的XML配置⽂件，并且要以<beans>元素为根。

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans";xmlns:xsi="/2001/XMLSchema-instance";xmlns:context="/schema/context";xsi:schemaLocation="/schema/beans/schema/beans/spring-beans.xsd/schema/context"></beans>可以看出基本的XML配置就已经⽐JavaConfig复杂很多。

⽤来装配bean的最基本的XML元素包含在spring-beans模式中，在上⾯这个XML⽂件中，它被定义为根命名空间。

<beans>是该模式中过的⼀个元素，它是所有Spring配置⽂件的根元素。

声明⼀个简单的<bean>使⽤spring-beans模式中的另外⼀个元素：<bean>，该元素类似于JavaConfig中的 @Bean注解。

Spring详解（六）----SpringBean的装配（基于XML的方式）

Spring详解（六）----SpringBean的装配（基于XML的⽅式）1、回顾依赖注⼊的三种⽅式在前⾯第三章中()介绍了什么是依赖注⼊和它们的简单应⽤，它有3种⽅式：构造器注⼊setter⽅法注⼊接⼝注⼊其中构造器注⼊和setter注⼊是最主要的⽅式，下⾯进⾏简单回顾⼀下。

①、构造器注⼊：顾名思义就是被注⼊对象可以通过在其构造⽅法中声明依赖对象的参数列表，让外部（通常是IoC容器）知道它需要哪些依赖对象。

在⼤部分的情况下，我们都是通过类的构造⽅法来创建类对象，Spring 也可以采⽤反射的⽅式，通过使⽤构造⽅法来完成注⼊，这就是构造器注⼊的原理。

⾸先要创建⼀个具体的类、构造⽅法并设置对应的参数，这⾥以User为例：/*** ⽤户实体类*/public class User {private int userId;private String userName;private int userAge;private String userPwd;private String userAddress;//getter、setter、toString⽅法省略......//有参构造器public User(int userId, String userName, int userAge,String userPwd, String userAddress) {erId = userId;erName = userName;erAge = userAge;erPwd = userPwd;erAddress = userAddress;}}如果我们在实体类中创建了有参的构造器，⽽没有显⽰的创建⽆参构造器，那么是不能再通过⽆参的构造器创建对象了，为了使Spring 能够正确创建这个对象，可以像如下Spring配置去做。

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans.xsd"><bean id="user" class="er"><constructor-arg index="0" value="2020"/><constructor-arg index="1" value="菜逼唐"/><constructor-arg index="2" value="18"/><constructor-arg index="3" value="123456"/><constructor-arg index="4" value="地球中国"/></bean></beans>constructor-arg元素⽤于定义类构造⽅法的参数，其中index ⽤于定义参数的位置(从0开始)，⽽value 则是设置值，通过这样的定义Spring 便知道使⽤哪个构造⽅法去创建对象了。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

<ref bean=""/>
数组String[],Object[]
<list>
<element>---必须是同一数据类型
</list>
List集合
<list></list>
Set集合
<set>无序，但不可有重复元素</set>
Map集合
<map>键--String，值---Object </map>
作业---27页1,2
EJB--->>重量级---程序员需要自己搭建应用环境
和具体代码；
Spring---》》轻量级--
Spring2.0之后，模块合成为6个；
保持好奇心---》》查询---》》划分---》》归纳
-----------------------------------------------------------
Resource res=new ClassPathResource("beans.xml");
BeanFactory fac=new XmlBeanFactory(res);
2---ApplicationContext
实现了BeanFactory的全部功能，除此之外，还具备框架功能；消息机理；
----------------------------------------------------
<ref>标签中local与bean 在引用类类型的区别：
local---》》所引用的对象必须在本xml文件当中；
bean---》》》所引用的对象既可以在本xml文件，也可以跨xml文件使用；
<constructor-arg></constructor-arg>
Spring如何管理Bean？？？？
SpringIOC完成依赖注入三种方式
1常用的注入方法----setter方法注入----（完成依赖注入时，只需提供setter方法即可）----<property>
2----构造方法注入-----<constructor-arg index="下标">
DataSource---singleton
action----prototype
--------------------------------------
parent="per"----用于继承关系时，子类中加parent，“父类的id”
------------------------------------------
<map><entry key=""></entry> </map>
properties
<props><prop key="">value<prop></props>
SpringIOC 容器接口对象的区别：
1---BeanFactory(Resource读取xml文件)
实现了SpringIOC容器的基本功能；
ApplicationContext ctx=
new FileSystemXmlApplicationContext(paths);
【推荐使用ApplicationContext】
Spring框架默认配置文件名----applicationContext.xml
ApplicationContext ctx=new FileSystemXmlApplicationContext("src/bean1.xml");
//如何读取多个xml文件
String [] paths=new String[]{"src/beans.xml","src/bean1.xml"};
scope=""----定义的是此对象的共享范围---
---singleton为默认值，单例---容器只生成1个对象；
----prototype--原型模式，---容器调用一次就生成一个新对象；
----request---request范围内生成一个对象
----session---session范围内生成一个对象
Spring IOCContainer
重点之一就是-----学习配置xml文件；
id---引用名
class-----类路径
abstract="true"-----设置为抽象的（抽象类或接口）
bean标签中各个属性的含义
------------------------------
3----接口注入----<ref &g-----------
SpringIOC容器如何实现不同数据类型的注入
基本数据类型Integer，Float，Double
<value></value>
类类型
<ref local=""/>
Spring+Hibernate框架结合，Spring容器会反转Hibernate基础对象(DataSource,SessionFatory,DAO)控制权;
Spring--->>>DAO
Hibernate--->>>ORMapping ---->>>POJO ,hbm.xml
----------------------------------------------------