Spring框架和Eclipse中配置Spring
最近打算买一个JSP的空间，价钱已经商量好了，大概在100RMB/M/Y，再加独立MySQL50M空间，国内双线访问，感觉不错。现在在寻觅一个JSP的个人博客系统，网上发现一个MyBlog系统，感觉非常不错，现在的版本是1.8PI，而且作者每天都在自己的博客
（http://www.jdkcn.com）上解答问题，很热心，于是下载下来观摩，可惜单纯的JSP页面少之又少，基本看不懂，作者告知系统使用了spring和Hibernet以及markframe框架。于是狠下心来决定学习一下JAVA主流框架。
首当其冲的是Spring。
一天下来又是电子书，又是视频教程，基本了解了Spring框架的核心思想。IoC，控制反转又称依赖注入。这套技术使用的目的是降藕，让各个类之间的关系变成松耦合状态。 比方说主类中想调用工程中另一个类，最基本的做法是直接import后，实例化这个类的一个对象，就可访问这个类的一些变量和函数了。再高级一点是使用工厂模式，用一个静态工厂取出这个类的实例化对象。这两种方法都无可避免在主类中创建或者说实例化我们想调用的这个类的对象，然而根据现在软件工程的理论，主类和调用类之间的耦合程度就变得非常紧密，因为在程序代码中已经将这两个类牢牢绑定在一起，要想调用别的类，就必须修改程序代码。
无论哪种Java设计模式都告诉我们尽量对接口编程，而不是对类编程。在上一个例子中，如果使用Spring框架我们无需再主类中实例化调用类，而是通过XML配置文件告诉主类我们将取出一个什么对象，通常我们称之为Bean，只要在XML文件中配置好需要调用的Bean的信息，在程序一开始，Spring就帮你全部实例化在Spring容器中，当主类想调用一个Bean的时候，不是实例化，而是根据相关XML配置，通过Java反射机制向容器索取一个需要的对象出来，等用完了还将返还给Spring容器，这有点像数据库技术中使用到的数据源的概念了。
闲话少说，我们举一个示例：
首先写一个基本的Pojo类，这是一种只有变量和相关set和get方法的类，非常纯粹赶紧，我们称之为Car
[Java]
1. package test;
2. /**
3. * @author newflypig
4. * @name:Car.java
5. */
6. public class Car {
7. String name;
8.
9. public String getName() {
10. return name;
11. }
12.
13. public void setName(String name) {
14. this.name = name;
15. }
16. }
接着我们的程序需要对Car进行相关的操作，这些操作函数一般放在一些名为Service的类中，所以我们打算新建一个CarService的类，但是根据主流的JAVA编程理念，我们首先需要确定我们对Car进行什么操作，这里就定义一个简单的输出汽车名字的操作，决定好操作目的后，制定一个接口名为CarServiceInterface的接口：
[Java]
1. package test;
2.
3. /**
4. * @name:CarServiceInterface.java
5. */
6. public interface CarServiceInterface {
7. public void printName();
8. }
紧接着，写一个类实现这个接口，名为CarService：
[Java]
1. package test;
2.
3. public class CarService implements CarServiceInterface{
4. private Car c;
5. public void setCar(Car c){
6. this.c=c;
7. }
8. public void printName(){
9. System.out.println(c.getName());
10. }
11. }
可以看到，这个Service中包含一个Car变量，而且这个变量是靠set方法传进来的，这一点很重要，Spring框架需要代码具有良好的编程规范，set小写，Car大写第一个字母，因为Spring框架需要根据即将编写的XML文件，通过Java反射机制找到我们这个Service类中setCar方法，并且将一个配置好的Car放进去。也就是说set方法并不是让我们来调用的，而是Spring自动来调用的，并且其中的参数，一个Car对象，也是Spring通过我们的XML来形成的。好了，具体的讲解有很多，大家可以到网上找专业的讲座，我们这里继续往下走，到了编写XML配置文档这个步骤了，新建一个config.xml的文件：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPTING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="car" class="test.Car">
<property name="name" value="BMW"></property>
</bean>
<bean id="carService" class="test.CarService">
<property name="car" ref="car"></property>
</bean>
</beans>
这份配置文档的作用有两个，第一个是定义了Car类的一个对象，这个Bean在整个程序中的标志，大家看第一个<bean>标签，可以看到，这个Bean的id是car，对应的类的路径也定位好了，其中Car的name属性也被定义好了，是“BMW”牌子的一辆车。第二个作用是定义了一个CarService的一个实例化对象，这个类是一个有真实作用的类，大家还记得它继承于CarServiceInterface接口吧，主函数中我们并不直接调用CarService而是使用它的接口来获得它的引用，这就是Spring以及其他所有主流框架所倡导的面向接口的编程。继续看这份XML，可以看到我们这个CarService的对象中给它注入了一个属性，这个属性就是car，也就是CarService中的一个private属性，Spring解析到这个标签后，通过反射机制找到CarService类中的setCar方法，将这个car对象注入进去，从而完成了一次漂亮的外部注入，而这种注入属性的技术完全不必在程序中实例化和定义对象，通过XML文档来操作，而且我们知道Java通过jdom和dom4j等工具可以方便得操作XML，我们可以在项目部署的时候写好XML，也可以在项目运行过程中动态得形成XML，从而增强了整个强木的高
可配置性，有效降低了系统的耦合程度。
万事俱备只欠东风，最后一个主类的编写，Main.java:
[Java] view plaincopy 1. package test;
2.
3. import org.springframework.context.ApplicationContext;
4. import org.springframework.context.support.ClassPathXmlApplicationContext; 5.
6. public class Main {
7.
8. /**
9. * @name:Main.java
10. */
11. public static void main(String[] args) {
12. ApplicationContext context=new ClassPathXmlApplicationContext("confi
g.xml");
13. CarServiceInterface carService=(CarServiceInterface)context.getBean(
"carService");
14. carService.printName();
15. }
16.
17. }
引入的两个类都是spring.jar中的，只要从官方网站上下载下来放到eclipse的builde path中就可以了，程序在Java虚拟机中运行后，运行到第一句话后，即在内存中形成Spring容器，并且在容器中实例化两个bean，也就是在指定的XML文档中配置好的两个bean。程序运行到第二句，大家可以看到，我并没有实例化CarService，而是使用了它的接口
CarServiceInterface，这个接口获得了一个引用，而这个引用是由Spring容器传过来的，id为carService的一个Bean，显然，在XML中，我们给这个bean赋予的是一个CarService对象，呵呵，到此为止整个程序就完成了。
这就是整个Spring的核心思想所在。当然Spring对于J2EE项目有着更为高级的支持，希望大家在学习了JAVA语言和jsp技术以后，多多掌握一些主流框架，对将来就业有极大的帮助，我们一起努力，谢谢阅读本文。
第二篇：spring学习总结
Spring学习
一、Spring 框架的相关介绍
1.1、Spring 框架的作用：
Spring是一个容器性质的框架.可以管理Bean对象的创建和销毁。
Spring容器具有IoC和AoP特性。
1.2、Ioc和Aop的概念
IoC : Inverse of Controll 反向控制或控制反转。
AoP : Aspect of Programming 切面编程。
1.3、Spring容器的对象管理
引入spring.jar和commons-logging.jar两个基本包。
1、创建容器配置文件,添加<bean>的定义
<bean id="别名" class="包名.类名"/>
2、创建容器对象,获取bean对象
ApplicationContext ctx =
new ClassPathXmlApplicationContext("applicationContext.xml")； ctx.getBean("别名")；
1.4、使用工厂方式创建对象
1、容器通过反射创建
2、工厂方法
3、静态工厂方法
1.5、对象的生命周期
1、对象创建时机
默认是在容器创建时,将对象创建出来。
可以在<bean/>元素中使用lazy-init="true",将该对象指定为使用
时创建。
2、指定对象初始化和销毁方法
可以在<bean/>元素中使用init-method="方法名"指定初始化方法
可以在<bean/>元素中使用destroy-method="方法名"指定销毁方法,次属性只对单例模式有效。
init方法在创建对象时执行,destroy方法在销毁容器时执行。
3、默认情况下,容器创建的对象的模式是一个单例模式。
可以在<bean/>元素中使用scope指定创建模式.默认为singleton,可以指定为prototype。
4、如果应用于Web环境中,可以指定为request,session,global session。
1.6、DI(依赖注入) Dependence Inject
1、setter方法注入(推荐使用)
<property name="personDao" ref="personDao2"/>
2、构造方法注入
<constructor-arg index="0" ref="personDao">
</constructor-arg>
3、注解方式注入
二、集合属性注入
2.1、常用注入类型属性值
注入Set,List,Map,Properties类型的属性值
2.2、注解方式配置
注解可以简化XML配置.
1、自动扫描(引入common-annotation.jar包)
a、首先在spring主配置文件中添加 <context:component-scan base-package="包路径"/>
b、在class中使用注解,指定哪些Bean被纳入容器。
@Component、@Controller、@Service、@Repository
注意 : 扫描的组件默认别名为"类名首字母小写",可以在注解中指 定别名,格式为:@Service("别名")
2、生命周期控制及scope创建模式
@PostConstruct 等价于<bean/>元素中的init-method
@PreDestroy 等价于<bean/>元素中的destroy-method
@Scope("prototype")等价于<bean/>元素中的scope="prototype"属
性。
3、注入
a、 @Autowired : 按类型匹配注入.如果需要按照名称,可以使用@Qualifier("personDao")指定Bean别名。
@Autowired(required=false) : required属性表示该属性是否必须注入一个对象。
b、@Resource : 默认先按名称,再按类型.如果需要按照名称,可以使用@Resource(name="personDao")。
注意:如果单独使用(2),(3)注解,需要在spring配置中添加。
<context:annotation-config/>
如果使用(1),(2),(3)注解,只需要指定自动扫描配置就可以。
<context:component-scan base-package="包路径"/>
c、AOP
AOP:面向切面编程.是对OOP编程的提升,可改善程序结构。
主要思想是将共通处理封装成切面对象,利用Spring容器将切面对象 作用到某一批目标对象之上。当执行目标对象方法时,会执行切面对象的功能。
相关概念
1、 切面:用于封装共通处理(即关注点),将来用于横切多个目标对象。
2、 连接点:程序在调用时的某个特定点,比如方法调用或者异常处理。
3、切入点: 连接点的集合,一个连接点集合的表达式(与正则表达式相似)。
4、通知:在连接点上执行的动作,比如前置通知,后置通知,异常通知,环绕通知,最终通知。
5、织入:把切面连接到其他应用程序类型或对象上.该过程在运行时完成。
6、目标对象:目标对象。
7、AOP代理:Spring容器会为每一个目标对象动态创建一个AOP代理对象。
2.3、AOP示例(注意:引入
aspectjrt.jar,aspectjweaver.jar,cglib-nodep-2.1_3.jar)。
a、execution - 匹配方法执行的连接点，这是你将会用到的Spring的最主要的切入点指示符。
b、execution（modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern（param-pattern）throws-pattern?）
c、任意公共方法的执行： execution（public * *（..））
任何一个名字以“set”开始的方法的执行： execution（* set*（..）） d、 AccountService接口定义的任意方法的执行：
execution（* com.xyz.service.AccountService.*（..））
e、 在service包中定义的任意方法的执行：
execution（* com.xyz.service.*.*（..））
f、 在service包或其子包中定义的任意方法的执行：
execution（* com.xyz.service..*.*（..））
2.4、AOP注解配置
1、在spring配置文件中启用AOP注解： <aop:aspectj-autoproxy/> 2、编写切面组件,使用以下注解定义切入点,通知等： @Aspect : 将当前类指定为切面组件 @Pointcut : 定义切入点 @Around("切入点引用") @Before("切入点引用") @After("切入点引用") @AfterReturning(pointcut="切入点",returning="参数名") @AfterThrowing(pointcut="切入点",throwing="参数名")
2.5、切入点定义
1、execution表达式 : 匹配方法的连接点。 (modifiers-pattern? ret-type-pattern execution
declaring-type-pattern? name-pattern（param-pattern）throws-pattern?)
2、bean表达式 : 匹配容器中bean对象的id或name属性值
bean (idOrNameOfBean)
3、within表达式: 匹配某一个或某一批特定类型within(包名.类
型)
示例1:在com.xyz.service.DeptService接口中的任意连接点 within（com.xyz.service.DeptService）
示例2:在service包中的任意连接点 within（com.xyz.service.*） 示例3:在service包或其子包中的任意连接点 within（com.xyz.service..*） 4、this和target : 匹配某一个类型实例的任意连接点.与within
区别在于不允许使用通配符。
this(代理对象类型),target(目标对象类型)。 示例1 : 实现了AccountService接口的代理对象的任意连接点。 this (com.xyz.service.AccountService) 示例2 : 实现AccountService接口的目标对象的任意连接点。 target (com.xyz.service.AccountService) 5、args表达式 : 匹配方法参数类型的连接点 args (参数类型) 示例1 : 任何一个只接受一个参数，并且运行时所传入的参数 是Serializable 接口的连接点 args (java.io.Serializable) 6、以上表达式可以使用运算符组合 ||,&&,!,and,or,not
二、总结
3.1、Spring框架作用
Spring框架提供了一套完整的企业级解决方案.基于该框架可以整合现有流行的Struts,Hibernate等框架.可以降低各层组件之间的依赖性.
3.4、Spring框架对JDBC的支持
1、引入数据库驱动和dbcp连接池的jar包。
commons-dbcp.jar,commons-pool.jar,commons-collections.jar,mysql-connector-java-5.1.6-bin.jar。
2、在spring配置文件中添加dataSource的定义。
3、编写DAO组件,使用JdbcTemplate工具类。
4、在spring配置文件中添加dao定义,注入dataSource对象。