作业帮spring
来源：学生作业帮助网 编辑：作业帮 时间：2024/09/25 14:28:12 体裁作文
篇一：spring注解详细介绍
使用Spring2.5的Autowired实现注释型的IOC 161641
使用Spring2.5的新特性——Autowired可以实现快速的自动注入，而无需在xml文档里面
添加bean的声明，大大减少了xml文档的维护。（偶喜欢这个功能，因为偶对xml不感冒）。 以下是一个例子：
先编写接口Man：
public interface Man {
public String sayHello();
}
然后写Man的实现类Chinese和American：
@Service
public class Chinese implements Man{
public String sayHello() {
return "I am Chinese!";
}
}
@Service
public class American implements Man{
public String sayHello() {
return "I am American!";
}
}
@Service注释表示定义一个bean，自动根据bean的类名实例化一个首写字母为小写的bean，例如Chinese实例化为chinese，American实例化为american，如果需要自己改名字则:@Service("你自己改的bean名")。
beans.xml
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-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
在spring的配置文件里面只需要加上
@Service
public class Main {
@Autowired
@Qualifier("chinese")
private Man man;
public static void main(String[] args) {
// TODO code application logic here
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml"); Main main = (Main) ctx.getBean("main");
System.out.println(main.getMan().sayHello());
}
public Man getMan() {
return man;
}
}
在Man接口前面标上@Autowired和@Qualifier注释使得Man接口可以被容器注入，当Man接口存在两个实现类的时候必须指定其中一个来注入，使用实现类首字母小写的字符串来注入。否则可以省略，只写@Autowired
**********************
使用 Spring 2.5 注释驱动的 IoC 功能
注释配置相对于 XML 配置具有很多的优势：
它可以充分利用 Java 的反射机制获取类结构信息，这些信息可以有效减少配置的工作。如使用 JPA 注释配置 ORM 映射时，我们就不需要指定 PO 的属性名、类型等信息，如果关系表字段和 PO 属性名、类型都一致，您甚至无需编写任务属性映射信息——因为这些信息都可以通过 Java 反射机制获取。
注释和 Java 代码位于一个文件中，而 XML 配置采用独立的配置文件，大多数配置信息在程序开发完成后都不会调整，如果配置信息和 Java 代码放在一起，有助于增强程序的内聚性。而采用独立的 XML 配置文件，程序员在编写一个功能时，往往需要在程序文件和配置文件中不停切换，这种思维上的不连贯会降低开发效率。
因此在很多情况下，注释配置比 XML 配置更受欢迎，注释配置有进一步流行的趋势。Spring
2.5 的一大增强就是引入了很多注释类，现在您已经可以使用注释配置完成大部分 XML 配置的功能。在这篇文章里，我们将向您讲述使用注释进行 Bean 定义和依赖注入的内容。
原来我们是怎么做的
在使用注释配置之前，先来回顾一下传统上是如何配置 Bean 并完成 Bean 之间依赖关系的建立。下面是 3 个类，它们分别是 Office、Car 和 Boss，这 3 个类需要在 Spring 容器中配置为 Bean：
Office 仅有一个属性：
清单 1. Office.java
package com.baobaotao;
public class Office {
private String officeNo =”001”;
//省略 get/setter
@Override
public String toString() {
return "officeNo:" + officeNo;
}
}
Car 拥有两个属性：
清单 2. Car.java
package com.baobaotao;
public class Car {
private String brand;
private double price;
// 省略 get/setter
@Override
public String toString() {
return "brand:" + brand + "," + "price:" + price;
}
}
Boss 拥有 Office 和 Car 类型的两个属性：
清单 3. Boss.java
package com.baobaotao;
public class Boss {
private Car car;
private Office office;
// 省略 get/setter
@Override
public String toString() {
return "car:" + car + "\n" + "office:" + office;
}
}
我们在 Spring 容器中将 Office 和 Car 声明为 Bean，并注入到 Boss Bean 中：下面是使用传统 XML 完成这个工作的配置文件 beans.xml：
清单 4. beans.xml 将以上三个类配置成 Bean
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-2.5.xsd">
当我们运行以下代码时，控制台将正确打出 boss 的信息：
清单 5. 测试类：AnnoIoCTest.java
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class AnnoIoCTest {
public static void main(String[] args) {
String[] locations = {"beans.xml"};
ApplicationContext ctx =
new ClassPathXmlApplicationContext(locations);
Boss boss = (Boss) ctx.getBean("boss");
System.out.println(boss);
}
}
这说明 Spring 容器已经正确完成了 Bean 创建和装配的工作。
使用 @Autowired 注释
Spring 2.5 引入了 @Autowired 注释，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。来看一下使用 @Autowired 进行成员变量自动注入的代码：
清单 6. 使用 @Autowired 注释的 Boss.java
package com.baobaotao;
import org.springframework.beans.factory.annotation.Autowired;
public class Boss {
@Autowired
private Car car;
@Autowired
private Office office;
…
}
Spring 通过一个 BeanPostProcessor 对 @Autowired 进行解析，所以要让 @Autowired 起作用必须事先在 Spring 容器中声明 AutowiredAnnotationBeanPostProcessor Bean。 清单 7. 让 @Autowired 注释工作起来
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-2.5.xsd">
这样，当 Spring 容器启动时，AutowiredAnnotationBeanPostProcessor 将扫描 Spring 容器中所有 Bean，当发现 Bean 中拥有 @Autowired 注释时就找到和其匹配（默认按类型匹配）的 Bean，并注入到对应的地方中去。
按照上面的配置，Spring 将直接采用 Java 反射机制对 Boss 中的 car 和 office 这两个私有成员变量进行自动注入。所以对成员变量使用 @Autowired 后，您大可将它们的 setter 方法（setCar() 和 setOffice()）从 Boss 中删除。
篇二：什么是Spring,他有什么特点？
什么是Spring,他有什么特点？
Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。
◆轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并 且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：
典型地，Spring应用中的对象不依赖于Spring的特定类。
◆控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦 合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不 是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依
赖传递给它。
◆面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的 业务逻辑与系统级服务（例如审计（auditing）和事务（）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们 并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。 ◆容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是 一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生 成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统
的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。
◆框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），
将应用逻辑的开发留给了你。
使用Spring有什么好处？
◆Spring能有效地组织你的中间层对象,无论你是否选择使用了EJB。如果你仅仅使用了Struts或其他的包含了J2EE特有APIs的framework，你会发现Spring关注了遗留下的问题，。
◆Spring能消除在许多工程上对Singleton的过多使用。根据我的经验，这是一个主要的问题，它减
少了系统的可测试性和面向对象特性。
◆Spring能消除使用各种各样格式的属性定制文件的需要,在整个应用和工程中，可通过一种 一致的方法来进行配置。曾经感到迷惑，一个特定类要查找迷幻般的属性关键字或系统属性,为此不得不读Javadoc乃至源编码吗？有了Spring，你可 很简单地看到类的JavaBean属性。倒置控制的使用(在下面讨论)帮助
完成这种简化。
◆Spring能通过接口而不是类促进好的编程习惯，减少编程代价到几乎为零。
◆Spring被设计为让使用它创建的应用尽可能少的依赖于他的APIs。在Spring应用中的大多数业务
对象没有依赖于Spring。
◆使用Spring构建的应用程序易于单元测试。
◆Spring能使EJB的使用成为一个实现选择,而不是应用架构的必然选择。你能选择用POJOs或
local EJBs来实现业务接口，却不会影响调用代码。
◆Spring帮助你解决许多问题而无需使用EJB。Spring能提供一种EJB的替换物，它们适于许多web应用。例如,Spring能使用AOP提供声明性事务而不通过使用EJB容器，如果你仅仅需要与单个的数
据库打交道，甚至不需要JTA实现。
■Spring为数据存取提供了一致的框架,不论是使用JDBC或O/R mapping产品（如Hibernate）。
Spring确实使你能通过最简单可行的解决办法解决你的问题。这些特性是有很大价值的。
总结起来，Spring有如下优点：
◆低侵入式设计，代码污染极低
◆ 独立于各种应用服务器，可以真正实现Write Once,Run Anywhere的承诺
◆Spring的DI机制降低了业务对象替换的复杂性
◆Spring并不完全依赖于Spring，开发者可自由选用Spring框架的部分或全部
Spring框架有哪几部分组成？
Spring框架有七个模块组成组成，这7个模块(或组件)均可以单独存在，也可以与其它一个或多个模块联合使用，主要功能表现如下：
? Spring 核心容器（Core）：提供Spring框架的基本功能。核心容器的主要组件是BeanFactory，她是工厂模式的实现。BeanFactory使用控制反转（Ioc）模式将应用程序的配置和依赖性规范与实际的应用代码程序分开。
? Spring AOP：通过配置管理特性，Spring AOP模块直接面向方面的编程功能集成到了Spring框架中，所以可以很容易的使Spring框架管理的任何对象支持 AOP。Spring AOP模块为基于Spring的应用程序中的对象提供了事务管理服务。通过使用Spring AOP，不用依赖于EJB组件，就可以将声明性事务管理集成到应用程序中。
? Spring ORM：Spring框架集成了若干ORM框架,从而提供了ORM的对象关系工具,其中包括 JDO、Hibernate、iBatis和TopLink。所有这些都遵从Spring的通用事务和DAO异常层结构。
? Spring DAO：JDBC DAO抽象层提供了有意义的异常层次的结构，可用该结构来管理异常处理和不同数据供应商抛出的异常错误信息。异常层次结构简化了错误处理，并且大大的降低 了需要编写的异常代码数量（例如，打开和关系连接）。Spring DAO的面向JDBC的异常遵从通用的DAO异常层结构。
? Spring WEB：Web上下文模块建立在上下文模块（Context）的基础之上，为基于Web服务的应用程序提供了上下文的服务。所以Spring框架支持 Jakarta Struts的集成。Web模块还简化了处理多部分请求及将请求参数绑定到域对象的工作。
? Spring上下文（Context）：Spring上下文是一个配置文件，向Spring框架提供上下文信息。Spring上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化校验和调度功能。
? Spring MVC：Spring的MVC框架是一个全功能的构建Web应用程序的MVC实现。通过策略接口，MVC框架变成为高度可配置的，MVC容纳的大量视图技术，包括JSP、Velocity、Tiles、iText和Pol
Spring如何获取Bean?
通过xml配置文件
bean配置在xml里面，spring提供多种方式读取配置文件得到ApplicationContext.
第一种方式：FileSystemXmlApplicationContext
通过程序在初始化的时候，导入Bean配置文件，然后得到Bean实例:
ApplicationContext ac = new FileSystemXmlApplicationContext(”applicationContext.xml”)
ac.getBean(”beanName”);
第二种方式：WebApplicationContextUtil
在B/S系统中,通常在web.xml初始化bean的配置文件，然后由WebAppliCationContextUtil得到
ApplicationContext.例如：
ApplicationContext ctx =
WebApplicationContextUtils.getRequiredWebApplicationContext(ServletContext sc);
ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(ServletContext
sc);
其中 servletContext sc 可以具体 换成 servlet.getServletContext()或者 this.getServletContext()
或者 request.getSession().getServletContext();
另外，由于spring是注入的对象放在ServletContext中的，所以可以直接在ServletContext取出
WebApplicationContext 对象：
WebApplicationContext webApplicationContext = (WebApplicationContext)
servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBU
TE);
1、 简述你对IoC（Inversion of Control）的理解，描述一下Spring中实现DI（Dependency Injection）的几种方式。
2、 Spring的Bean有多种作用域，包括：
singleton、prototype、request、session、global session、application、自定义
3、 简单描述Spring Framework与Struts的不同之处，整合Spring与Struts有哪些方法，哪种最好，为什么？
4、 Hibernate中的update()和saveOrUpdate()的区别
5、 Spring对多种ORM框架提供了很好的支持，简单描述在Spring中使用Hibernate的方法，并结合事务管理。
--------------------------------------------------------------------------------
答案：
1、 好莱坞原则——不要打电话找我，我会打给你的。IoC将创建的职责从应用程序代码搬到了框架中。Spring对Setter注入和构造方法注入提供支持。（详见http://martinfowler.com/articles/injection.html，以及/spring_ref/2.0/html/beans.html#beans-factory-collaborators）
2、 除application（详见Spring Framework 2.0 Reference的3.4节bean的作用域）
3、 Spring是完整的一站式框架，而Struts仅是MVC框架，且着重于MVC中的C。Spring有三种方式整合Struts：使用 Spring 的 ActionSupport 类整合 Struts；使用 Spring 的 DelegatingRequestProcessor 覆盖 Struts 的 RequestProcessor；将 Struts Action 管理委托给 Spring 框架，动作委托最好。（详见使用Spring 更好地处理Struts 动作）
Spring 2.0新增一种方式：AutowiringRequestProcessor。（详见/topic/24239）
4、 saveOrUpdate()方法可以实现update()的功能，但会多些步骤，具体如下：
如果对象在该session中已经被持久化，不进行操作；
对象的标识符属性(identifier property)在数据库中不存在或者是个暂时的值，调用save()方法保存它；
如果session中的另一个对象有相同的标识符抛出一个异常；
以上皆不符合则调用update()更新之。
5、 在context中定义DataSource，创建SessionFactoy，设置参数；DAO类继承HibernateDaoSupport，实现具体接口，从中获得HibernateTemplate进行具体操作。在使用中如果遇到OpenSessionInView的问题，可以添加OpenSessionInViewFilter或OpenSessionInViewInterceptor。（详见Spring Framework 2.0 Reference的12.2节Hibernate） 声明式事务需声明事务管理器，在context中设置
文章出处：DIY部落(/course/3_program/java/javajs/200832/102302.html)
篇三：spring配置文件详细 原创
"> class="org.springframework.orm.hibernate3.LocalSessionFactoryBean
">
(以备自己日后查询)
Anyquestion qq:16895920
篇四：spring 内部操作详解
。 ApplicationContext覆盖了BeanFactory
的所有功能，并提供了更多的特性。此外，ApplicationContext为与现有应用框架相整合，提供了更为开放式的实现（如对于Web应用，我们可以在web.xml中对ApplicationContext进行配置。
一、看看如何通过Spring BeanWrapper操作一个JavaBean：
我对这三个类的理解是： xmlns:xsi="/retype/zoom/786b244733687e21af45a920?pn=2&x=0&y=0&raww=315&rawh=33&o=jpg_6_0_______&type=pic&aimh=33&md5sum=5965ad0cd490744b531729f199ea8be1&sign=20d47b24c5&zoom=&png=725-1352&jpg=8456-11020" target="_blank">点此查看
(转 载于:wWw.SmHaIDA.cOM 海达 范文 网:spring)System.out.println("User name=>"+bw.getPropertyValue("name"));
对比之前的代码，相信大家已经知道BeanWrapper的实现原理。
诚然，通过这样的方式设定Java Bean属性实在繁琐，但它却提供了一个通用的属性设定机制，而这样的机制，也正是Spring依赖注入机制所依赖的基础。 通过BeanWrapper，我们可以无需在编码时就指定JavaBean的实现类和属性值，通过在配置文件加以设定，就可以在运行期动态创建对象并设定其属性（依赖关系） 。
二、 Bean Factory
Bean Factory，顾名思义，负责创建并维护Bean实例。
Bean Factory负责根据配置文件创建Bean实例，可以配置的项目有：
1． Bean属性值及依赖关系（对其他Bean的引用）
2． Bean创建模式（是否Singleton模式，即是否只针对指定类维持全局唯一的实例）
3． Bean初始化和销毁方法
4． Bean的依赖关系
.Bean Factory的生命周期
下面是一个较为完整的Bean配置示例：
Bean的定义 id="beanId"（1） name="beanName"（2） class="beanClass"（3） parent="parentBean"（4） abstract="true | false"（5） singleton="true | false"（6） dependency-check = "none | objects | simple | all | default"（9） depends-on="dependsOnBean"（10） destroy-method="method"（12） factory-method="method"（13） factory-bean="bean">（14） （1）、id: Bean的唯一标识名。它必须是合法的XML ID，在整个XML文档中唯一。 （2）、name: 用来为id创建一个或多个别名。它可以是任意的字母符合。多个别名之间用逗号或空格分开。 （3）、class: 用来定义类的全限定名（包名＋类名）。只有子类Bean不用定义该属性。 （4）、parent: 子类Bean定义它所引用它的父类Bean。这时前面的class属性失效。 (16) 子类Bean会继承父类Bean的所有属性，子类Bean也可以覆盖父类Bean的属性。注意：子类Bean和父类Bean是同一个Java类。 （5）、abstract（默认为”false”）：用来定义Bean是否为抽象Bean。它表示这个Bean将不会被实例化，一般用于父类Bean，因为父类Bean主要是供子类Bean继承使用。 （6）、singleton（默认为“true”）：定义Bean是否是Singleton（单例）。如果设为“true”,则在BeanFactory作用范围内，只维护此Bean的一个实例。如果设为“flase”，Bean将是Prototype（原型）状态，BeanFactory将为每次Bean请求创建一个新的Bean实例。 spring singleton的含义是在一个spring 上下文中保持单态，如果一个jvm上多次加载spring context将使得单态的意义不复存在，与此会产生同步等问题 同一个ApplicationContext，两次getBean()取得的是同一个对象的引用。不同的 ApplicationContext，两次getBean()取得的是不同的对象 1. package ioc.demo; 2. 3. public class Company { 4. private String name; 5. 6. public String getName() { 7. return name; 8. } 9. 10. public void setName(String name) { 11. this.name = name; 12. } 13. } 14. 15. 16. 17. 篇五：Spring试题和答案 Spring考试试题 1)下面关于Spring的说话正确的是（B C）（选择两项） A）Spring是一个重量级的框架 B）Spring是一个轻量级的框架 C）Spring是一个IOC和AOP容器 D）Spring是一个入侵式的框架 2）下面关于IOC的理解，正确的是（A B）（选择两项） A）控制反转 B）对象被动的接受依赖类 C）对象主动的去找依赖类 D）一定要用接口 3）下面关于AOP的理解，正确的是（B C）（选择两项） A）面向纵向的开发 B）面向横向的开发 C）AOP关注是面 D）AOP关注的是点 △4）Spring的组成一共有（D）块组成。 A）1 B）3 C）5 D）7 5）Spring各模块之间关系（B C）（选择两项） A）Spring各模块之间是紧密联系的，相互依赖的 B）Spring各模块之间可以单独存在 C）Spring的核心模块是必须的，其他模块是基于核心模块 D）Spring的核心模块不是必须的，可以不要 6）Spring核心模块的作用（B） A）做AOP的 B）做IOC的，用来管理Bean的 C）是用来支持Hibernete D）是用来支持Struts的 7）对Hibernate的支持主要用到Spring的那个模块（B）（选择两项） A）Spring核心模块 B）Spring ORM模块 C）Spring MVC模块 D）Spring Web模块 8）对Struts的支持主要用到Spring的那个模块（D）（选择两项） A）Spring核心模块 B）Spring ORM模块 C）Spring MVC模块 D）Spring Web模块 9）Spring的通知类型有（A B C D）（多项选择） A）Before通知 B）After return通知 C）Throws通知 D）Around通知 △10）下面关于切入点的说法正确的是（A C D）（多项选择） A）是AOP中一系列连连接点的集合 B）在做AOP时定义切入点是必须的 C）在做AOP时定义切入点不是必须的 D）可以用正则表达式来定义切入点 11)Spring包装Hibernate之后的Hibernate的DAO应该继承那个类（C） A）HibernateDAO B）SessionFactory C）HibernateDAOSuport D）Session 12）下面对Spring包装Struts1.2的说法正确的是（B C）（选择两项） A）Spring包装Struts的ActionServlet B）Spring包装Struts的Action C）主要是利用Spring的依赖注入 D）主要利用Spring的面向方面的编程 13）Spring包装Struts时那些Spring模块是必须的（A D）（选择两项） A）Spring核心模块 B）Spring AOP模块 C）Spring MVC模块 D）Spring WEB模块 14)Spring中Before通知的目标对象要实现的接口是（A） A）MethodBeforeAdvice B）ThrowsAdvice C）AfterReturningAdvice D）MethodInterceptor △15）Spring中around通知的目标对象要实现的接口是（D） A）MethodBeforeAdvice B）ThrowsAdvice C）AfterReturningAdvice D）MethodInterceptor 16）Spring中Before通知的目标对象要实现的接口中before方法中的三个常用的参数依次是（A） A）方法，方法的参数，目标对象 B）方法的参数，方法，目标对象 C）目标对象，方法，方法的参数 D）方法的参数，目标对象，方法 17）Spring中around通知的目标对象要实现的接口中invoke中方法的参数是（C） A）方法 B）目标对象 C）方法执行参数 D）Exception 18）下面是Spring依赖注入方式的是（A B ）（选择两项） A）set方法注入 B）构造方法的注入 C）get方法的注入 D）接口的注入 19）下面关于在Spring中配置Bean的id属性的说法正确的是（B D）（选择两项） A）id属性是必须，没有id属性就会报错 B）id属性不是必须的，可以没有 C）id属性的值可以重复 D）id属性的值不可以重复 20）下面关于在Spring中配置Bean的name属性的说法正确的是（B D）（选择两项） A）name属性是必须，没有name属性就会报错 B）name属性不是必须的，可以没有 C）name属性的值可以重复 D）name属性的值不可以重复 21)下面是IOC自动装载方法的是（A B）（选择两项） A）byName B）byType C）constructor D）byMethod