【Spring】Spring之我见

【导图俯瞰全篇】

 

一，框架介绍：

          1，先看一下帮助文档的这张图，里边主要包括了Spring自身的功能，还有可以和其框架结合的一些框架，通过这张图可以看出，Spring框架和其他框架的集成能力是非常强的

2，Spring是一个轻量级的IOC和AOP容器框架：

                 a,轻量级：程序实现不是很复杂，代码不是很多，占用资源不是很多，没有侵入性；

                 b，IOC（Inversion of Control 控制反转）：对象创建责任的反转（重点，核心）原则的配置管理，使得应用程序的组件更加快捷简易。；

                 c, Aop(Aspect Oriented Programming):一种面向横切面编程的思想方式，可以进行功能性扩展

                 d，容器：可以容纳对象，并且可以控制对象的生命周期；

二、步骤

1、拷jar包

commons-logging.jar（日志输出操作，实现日志输入的转换）

spring-aop.jar

spring-core.jar

spring-context.jar

spring-beans.jar

spring-expression.jar

spring-web.jar

spring-tx.jar

aopalliance.jar

aspectjrt.jar

aspectjweaver.jar

2、拷贝框架的核心配置文件，存放在src目录下

applicationContext.xml（框架的核心配置文件）

3，编写框架的核心配置文件，将声明对象都交给Spring框架来创建，以及初始化，例如service层的类，action层类，dao层类等等，都可以交给Spring进行管理，看一个例子：

[html] view plain copy print ?

1. <span style="font-size:18px;">      <!-- 声明Action对象 -->  
2.   
3. <bean id="loginAction" class="com.ljh.struts2.action.LoginAction" scope="prototype"></bean> </span>
   

·创建对象方式：1、默认单例 scope="singleton"  2、原型模式： scope="prototype"原型模型确保每次检索都会创建单独的对象。在每个用户都需要自己的对象时，原型模型最适合。

·工厂BeanFactory:BeanFactory功能是对bean对象的生命周期进行管理的。（创建，初始化，销毁）

·ApplicationContext(推荐，也是框架默认的)

来用才对象来加载Spring配置文件，会在加载时解析配置文件，创建对象，而不是在getBean时实，ApplicationContext接口继承了BeanFactory，所以具备BeanFactory所有功能，同时增加扩展的功能，例如加载资源配置文件，国际化支持等！

4、加载 配置文件

利用beanFactory加载配置文件:

[java] view plain copy print ?

1. <span style="font-size:18px;">      //加载配置文件，创建Spring的应用环境  
2.         String path = "applicationContext.xml";       
3.         Resource resource = new ClassPathResource(path);    //推荐  
4.         //Resource resource = new FileSystemResource("src/applicationContext.xml");  
5.         //Resource resource = new ServletContextResource(servletContext, path); //如果文件存放到WEB-INF目录下  
6.           
7.         BeanFactory factory = new XmlBeanFactory(resource);  
8.   
9.         //从Spring环境中获取对象  
10.         Object obj = factory.getBean("loginAction");  
11.           
12.   
13. LoginAction action = (LoginAction)obj ; </span> 

利用ApplicationContext加载配置文件：

[java] view plain copy print ?

1. <span style="font-size:18px;">      ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");  
2.               
3.         Object obj = ac.getBean("loginAction");  
4. </span> 
   

三、优点

1.低侵入式设计，代码污染极低

2.独立于各种 应用服务器，基于Spring框架的应用，可以真正实现Write Once,Run Anywhere的承诺

3.Spring的DI机制降低了 业务对象替换的复杂性，提高了组件之间的解耦

4.Spring的AOP支持允许将一些通用任务如安全、事务、日志等进行集中式管理，从而提供了更好的复用

5.Spring的ORM和DAO提供了与第三方持久层框架的良好整合，并简化了底层的数据库访问

6.Spring并不强制应用完全依赖于Spring，开发者可自由选用Spring框架的部分或全部

7、用依赖注入模式大幅度的减少了程序之间的耦合性 并很好的实现了各种JAVA的设计模式 强制使用者养成用接口编程的习惯 

四、第一个Spring小程序

新建一个User类，一个UserDao类以及一个测试类：

User.java

[java] view plain copy

1. package com.adam.java.spring.po;  
2.   
3. public class User {  
4.     private String name;  
5.     private int age;  
6.     private int score;  
7.     public String getName() {  
8.         return name;  
9.     }  
10.     public void setName(String name) {  
11.         this.name = name;  
12.     }  
13.     public int getAge() {  
14.         return age;  
15.     }  
16.     public void setAge(int age) {  
17.         this.age = age;  
18.     }  
19.     public int getScore() {  
20.         return score;  
21.     }  
22.     public void setScore(int score) {  
23.         this.score = score;  
24.     }  
25.       
26.     public String toString(){  
27.         return "tostring from user";  
28.     }  
29. }  

UserDao.java

[java] view plain copy

1. package com.adam.java.spring.dao;  
2.   
3. import com.adam.java.spring.po.User;  
4.   
5. public class UserDao {  
6.     private User user;  
7.       
8.     public void add(){  
9.         System.out.println("add from userdao");  
10.         System.out.println(user.toString());  
11.     }  
12.   
13.     public User getUser() {  
14.         return user;  
15.     }  
16.   
17.     public void setUser(User user) {  
18.         this.user = user;  
19.     }  
20.   
21.       
22. }  

DITest.java

[html] view plain copy

1. package com.adam.java.spring;  
2.   
3. import org.springframework.context.ApplicationContext;  
4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
5.   
6. import com.adam.java.spring.dao.UserDao;  
7.   
8. public class DITest {  
9.   
10.     @SuppressWarnings("resource")  
11.     public static void main(String[] args) {  
12.         ApplicationContext atx = new ClassPathXmlApplicationContext("beans.xml");  
13.         UserDao userDao = (UserDao) atx.getBean("userDao");  
14.         userDao.add();  
15.     }  
16.   
17. }  

一个配置文件beans.xml

[html] view plain copy

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans xmlns="http://www.springframework.org/schema/beans"  
3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">  
5.   
6. <bean id="user" class="com.adam.java.spring.po.User"/>  
7. <bean id="userDao" class="com.adam.java.spring.dao.UserDao">  
8.     <property name="user" ref="user"/>  
9. </bean>  
10. </beans>  

执行测试类，得出如下输出：

[html] view plain copy

1. add from userdao  
2. tostring from user