spring 入门篇

spring 入门篇

相对于Hibernate（冬眠），Spring（春天），具有更多的诗意与希望的感觉，是为了解决传统J2EE开发效率过低、开发商之间不统一、没有真正实现“写一次到处使用”，它的优点有如下：

  1. 低侵入式设计，代码污染极低。
  2. 独立于各种应用服务，真正实现写一次到处都可以使用。
  3. 用户可选择的自由度高，用户可以选择部分或者是全部SPRING的功能，它并不是设计来取代其它框架，可以和其它的框架（如STRUTS、HIBERNATE）等结合极好。
  4. 面向接口的编程方式，使得代码的偶合度降到最低。
  5. 所有的BEAN默认都被会单态化，相同的BEAN只会被初使化一次，因而节省了BEAN初使化的时间及减少垃圾回收，增加了应用效率。

...

有以上的优点的结合，因而它是被广大程序员所欢迎的，因为它可以给我们带来高效、稳定的开发，很大程度的减少了程序的开发、维护周期，也就自然的减少了软件开发的费用。下面简单的介绍两个应用示例，这些示例都来自于书本，都简单易懂，我也会详细的加以说明，另外需要使用下面的示例，需要引用Spring的JAR包：Spring.jar，该JAR包包括了大部份的应用，如果暂时不需要SPRINT的其它功能，该JAR足以。

以下的程序，全部都是调试通过的。

示例一、不同的人说不同的话 —— 简单的例子

1、建立接口

工厂模式在SRPING中是随处体现，且提倡面向接口，因此首先建立接口：人

  1. package test;
  3. publicinterfacePerson{
  4. publicvoid sayHello();
  6. publicvoid sayBye();
  7. }

2、建立两种具体的人：中国人、美国人

  1. //中国人
  2. package test;
  4. publicclassChineseimplementsPerson{
  5. publicvoid sayBye(){
  6. System.out.println("再见");
  7. }
  9. publicvoid sayHello(){
  10. System.out.println("你好");
  11. }
  12. }
  1. //美国人
  2. package test;
  4. publicclassAmericanimplementsPerson{
  5. publicvoid sayBye(){
  6. System.out.println("Bye");
  7. }
  9. publicvoid sayHello(){
  10. System.out.println("hello");
  11. }
  12. }

3、建立bean映射配置文件，bean.xml（放在放在刚才的类同目录下面，这个文件名是什么没有关系，在初使化的时候指定给初使化程序就可以）

  1. <?xml version="1.0" encoding="gb2312"?>
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
  3. "http://www.sprintframework.org/dtd/spring-beans.dtd">
  4. <beans>
  5. <beanid="chinese"class="test.Chinese"/>
  6. <beanid="american"class="test.American"/>
  7. </beans>

这样也行：

  1. <beansxmlns="http://www.springframework.org/schema/beans"
  2. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3. xsi:schemaLocation="http://www.springframework.org/schema/beans
  4. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
  6. <beanid="chinese"class="test.Chinese"/>
  7. <beanid="american"class="test.American"/>
  8. </beans>

4、建立JAVA测试类：

  1. package test;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  5. import org.springframework.context.support.FileSystemXmlApplicationContext;
  7. public class Lantch {
  8. public static void main(String[] args) throws Exception {
  9. new Lantch().doIt();
  10. }
  12. public void doIt() {
  13. /* 获取bean映射配置文件，配置文件放于与当前测试类在同一个目录下 */
  14. ApplicationContext ctx = new FileSystemXmlApplicationContext(getClass().getResource("bean.xml").toString());
  16. /* 配置文件放在 resources目录下面 */
  17. // ApplicationContext ctx = new ClassPathXmlApplicationContext("MATE-INF/bean.xml");
  19. Person person = null;
  20. person = (Person) ctx.getBean("chinese");
  21. person.sayHello();
  22. person.sayBye();
  24. person = (Person) ctx.getBean("american");
  25. person.sayHello();
  26. person.sayBye();
  27. }
  29. }

5、对以上示例调用的说明：

A）、对接口Person和具体实现类Chinese、American就没有什么需要说明的了，和其它的编程方式，都是先定义接口，实现类再通过继承接口实现其方法。

B）、映射类中将类的路径定义为一个id的名称，到时系统根据传到的id名称，到配置文件中去找到该类的绝对路径，再通过反射原理加载该类，并返回其对象，这个是通过getBean这个动作完成的。

C）、根据里氏代换原则，能够接收父类的地方，都可以接收子类，所以这个时候通过getBean返回的对象（如Chinese或者American），都可以赋给接口Person，这个时候接口类调用其中的方法的时候，因为这个时候父类实际上接受的是子类的对象，因而这个时候调用的就是指定子类的方法。这个时候Spring就帮我们完成了如下工作：

Person person=new Chinese();

只是子类不是通过显示给出来的，而是通过Spring工厂通过映射配置生成的。

示例二、设值注入

设值注入是依赖注入的一种，依赖注入早期叫控制反转，也可以称反射，他们的意义都相同。当某个 Java 实例(调用者)需要另一个Java 实例(被调用者)时，在传统的程序设计过程中，通常由调用者来创建被调用者的实例。而在依赖注入的模式下，创建被调用者的工作不再由调用者来完成，通常由 Spring 容器来完成，然后注入调用者，因此称为控制反转，也称为依赖注入。

1、建立接口：人与斧头

人，定义一个动作：

  1. package test2;
  3. publicinterfacePerson{
  4. publicvoid useAxe();
  5. }

斧头，定义一个动作：

  1. package test2;
  3. publicinterfaceAxe{
  4. publicvoid chop();
  5. }

2、建立接口的实现类：中国人与石斧

中国人

  1. package test2;
  3. publicclassChineseimplementsPerson{
  4. /* 默认无参构造方法不管为私的还是公有的，都可以访问，并且要保证bean中存在可以被外界访问的无参构造函数 */
  5. privateChinese(){
  6. };
  8. /* 定义需要被使用的斧头接口，具体使用什么斧头这里不管 */
  9. privateAxe axe;
  11. /*
  12. * 定义被注入斧头的set方法，该方法一定要符合JAVABEAN的标准。在运行时候，Sping就会根据配置的<ref
  13. * local=""/>，找到需要注入的实现类
  14. */
  15. publicvoid setAxe(Axe axe){
  16. this.axe = axe;
  17. }
  19. /* 这个时候使用的axe，就不再是接口Axe本身，而是被注入的子类实例，所以这里的chop()动作就是具体子类的chop动作 */
  20. publicvoid useAxe(){
  21. axe.chop();
  22. }
  23. }

石斧

  1. package test2;
  3. publicclassStoneAxeimplementsAxe{
  4. publicvoid chop(){
  5. System.out.println("石斧慢慢砍");
  6. }
  7. }

3、建立映射配置文件bean.xml：

  1. <?xml version="1.0" encoding="gb2312"?>
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
  3. "http://www.sprintframework.org/dtd/spring-beans.dtd">
  4. <beans>
  5. <beanid="chinese"class="test2.Chinese">
  6. <!-- 声明实现类test2.Chinese中的属性 -->
  7. <propertyname="axe">
  9. <!-- 指定其中声明的属性，需要用本地的那个id对应的class 这里local的值为"stoneAxe"，表示axe的属性值在注入的时候，
  10. 将会用test2.StoneAxe实例注入，到时在实例类Chinese中使用 axe的时候，实际上调用的时候StoneAxe的实例 -->
  12. <reflocal="stoneAxe"/>
  13. </property>
  14. </bean>
  15. <beanid="stoneAxe"class="test2.StoneAxe"/>
  16. </beans>

4、测试用例：

  1. package test2;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.FileSystemXmlApplicationContext;
  6. publicclassCaller{
  7. publicstaticvoid main(String[] args){
  8. Caller caller =newCaller();
  9. caller.doIt();
  10. }
  12. publicvoid doIt(){
  13. String bean = getClass().getResource("bean.xml").toString();
  14. ApplicationContext ctx =newFileSystemXmlApplicationContext(bean);
  15. Person person =(Person) ctx.getBean("chinese");
  16. person.useAxe();
  17. }
  18. }

5、对以上示例调用的说明：

程序及XML文件中都有详细说明，这里就不说明了。

三、构造注入：

构造注入即是通过构造函数进行注入，到目前为止，SPRINT支持设值注入与构造注入两种方式，它们可以同时存在。

现在采用的实例为了和设值注入进行对比，因此使用的程序都是设值注入的程序，其中的接口和测试实例都不需要修改，修改的只是需要被注入的实现类Chinese，以及配置文件，不同之处用加粗体表示。

1、修改实现类Chinese如下;

  1. package test2;
  3. publicclassChineseimplementsPerson{
  4. /* 默认无参构造方法不管为私的还是公有的，都可以访问，并且要保证bean中存在可以被外界访问的无参构造函数 */
  5. privateChinese(){
  6. };
  8. /* 定义需要被使用的斧头接口，具体使用什么斧头这里不管 */
  9. privateAxe axe;
  11. publicChinese(Axe axe){
  12. this.axe = axe;
  13. }
  15. /* 这个时候使用的axe，就不再是接口Axe本身，而是被注入的子类实例，所以这里的chop()动作就是具体子类的chop动作 */
  16. publicvoid useAxe(){
  17. axe.chop();
  18. }
  19. }

2、修改配置文件bean.xml：

  1. <?xml version="1.0" encoding="gb2312"?>
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
  3. "http://www.sprintframework.org/dtd/spring-beans.dtd">
  4. <beans>
  5. <bean id="chinese"class="test2.Chinese">
  7. <!--定义需要被构造注入的实现类，同设值注入的结果一样，都是注入接口的实现类-->
  9. <constructor-arg>
  10. <ref bean="stoneAxe"/>
  11. </constructor-arg>
  12. </bean>
  13. <bean id="stoneAxe"class="test2.StoneAxe"/>
  14. </beans>

3、设值注入与构造注入实现的结果是一样的，都在将需要被调用的实现类注入到调用的实现类。

设值注入与传统JAVABEAN的写法一样，比较容易接受；而构造注入在应用程序加载的时候就已经完成了注入，可以控制加载顺序。各有优缺点，根据不同的情况选用了。

四、后记

编程中理解与使用SPRING就像是人从学走路到跑步的过程，如果没有理解什么是单态模式、工厂模式、反射、JAVABEAN、XML基础、接口及其实现等等，理解SPRING就会比较困难，就算是可以使用通，也不一定知道为什么，看看网上的一些信息，动不动要求说会不会SPRING、HIBERNATE等等，很少提到基础知识是否扎实。我在面试别人的过程中，往往更注意面试人员的程序基础、编程风格、动手能力、文档编写能力等，当然对当前一些流行的框架也会有提问，毕竟好的东西也是需要借签的。

构件maven项目以及依赖：

先后执行命令：

-DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

mvn eclipse:eclipse

  1.     <properties>
  2. <spring.version>3.0.5.RELEASE</spring.version>
  3. </properties>
  5. <dependencies>
  6. <!-- Spring 3 dependencies -->
  7. <dependency>
  8. <groupId>org.springframework</groupId>
  9. <artifactId>spring-core</artifactId>
  10. <version>${spring.version}</version>
  11. </dependency>
  13. <dependency>
  14. <groupId>org.springframework</groupId>
  15. <artifactId>spring-context</artifactId>
  16. <version>${spring.version}</version>
  17. </dependency>
  19. </dependencies>

参考文章：http://blog.csdn.net/fenglibing/article/details/4300517

时间： 2024-10-10 04:26:35

spring 入门篇的相关文章

spring入门篇-学习笔记

1.spring IOC的作用就是用加载配置文件的方式代替在代码中new 对象的方式来实例化对象. 2.IOC 全称:Inversion  of Control,中文意思:控制反转 3.依赖注入有两种方式: 设值注入-> 通过添加set方法,并在配置文件的bean中添加property标签(property引用另一个bean)的方式注入 构造注入->通过构造方法,并在配置文件的bean中添加constructor-arg标签的方式注入 例子项目结构: 以下是各文件代码: InjectDao.j

spring入门篇2 --- IOC设计思想

在上一篇中已经大致了解了IOC的设计思想,IOC全拼是Inversion of Control,就是控制反转,以前我们都是自己创建对象,进行实例化,现在交给框架spring来进行控制,以实现高度的解耦. IOC是设计思想,是Spring的核心,我们必须要掌握,因此通过几个例子,来看看到底是如何实现的,这样就可以有更清晰的认知,所有的demo源码放在了github上,后续学习过程会进行持续的更新,以后不再赘述. 学习这个之前,我们需要了解一下什么是DI,Dependency Injection,依

spring入门篇10 --- springMVC入门小程序

继续昨晚没有完成的这个小demo,完成这个,我们基本上算入门 首先,这个demo继续使用注解方式,源码地址github 首先看一下这个,这个就是maven起的项目结构,使用SpringMVC起项目,webapp就会与src同级,但是我们一般把src当作源码目录,所以做好可以做到同级,但这个就是为了练习. 首先明确一下,DispatcherServlet是实现servlet接口,Dispatcher使用Spring配置文件告知spring他需要请求反射,视图解析,异常处理等,而我们项目一般是跑在t

慕课-《Spring入门篇》学习笔记 专题一 IOC

1.一些资源 http://spring.io/ http://projects.spring.io/spring-framework/ 2.什么是spring? 它是一个开源的框架,一个轻量级的控制反转(————达到松耦合的目的)IOc和面向切面(————)的容器框架,管理并配置应用对象的配置和生命周期. SPring带来了复杂的JavaEE开发的春天 ####################################################### 正式开始 1.接口:对应Jav

Spring入门篇——AOP基本概念

1.什么是AOP及实现方式 什么是AOP AOP:Aspect Oriented Programming的缩写,意为:面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术 主要的功能是:日志记录,性能统计,安全控制,事务处理,异常处理等等 AOP实现方式 预编译 -ApectJ 运行期动态代理(JDK动态代理.CGLib动态代理) -SpringAOP.JbossAOP 2.AOP基本概念 连接点:比如一个类中某个方法执行的开始 通知:在某个方法执行的时候,额外执行的切面

Spring入门篇

编码1.什么是框架 2.Spring简介 3.IOC(配置.注解) 4.Bean(配置.注解) 5.AOP(配置.注解.AspectJ.API) 如何学习Spring 掌握用法 深入理解 不断实践 反复总结 再次深入理解与实践 似乎是学习所有技术的方式... 学习Spring的资源 http://spring.io/ http://projects.spring.io/spring-framework/ Spring是什么 控制反转(IOC):把控制权交出去,在使用的过程中直接去得到这样的对象

Spring入门篇——第2章 Spring IOC容器

第2章 Spring IOC容器 介绍Spring IOC容器的基本概念和应用 2-1 IOC及Bean容器 在IOC容器中,所有对象都称为bean 2-2 Spring注入方式 原文地址:https://www.cnblogs.com/songsongblue/p/9895536.html

Spring课程 Spring入门篇 3-2 Spring bean装配（上）之bean的生命周期

本节主要讲了三大块内容 1 bean的生命周期概念 2 bean的初始化和销毁的三种方式对比(代码演练) 3 总结 1 bean的生命周期概念 1.1 bean的定义:xml中关于bean的配置,bean的id和bean的class等. 1.2 bean的初始化:ioc容器启动的时候加载xml文件中的bean生成实例. 1.3 bean的使用:bean容器中取出bean的实例并使用 1.4 bean销毁:指的是bean销毁时回收由这个bean创建的所有bean实例. 2 bean的初始化和销毁的

Spring课程 Spring入门篇 4-6 Spring bean装配之基于java的容器注解说明--@ImportResource和@Value java与properties文件交互

1 解析 1.1 这两个注解应用在什么地方 1.2 应用方式 1.3 xml方式实现取值 2 代码演练 2.1 @ImportResource和@Value代码演练 1 解析 1.1 这两个注解应用在什么地方 接口调用,java与properties文件交互获取url和用户名密码等配置信息 1.2 应用方式 java类通过调用@Importresource找到xml,通过xml配置properties 示例: @Configuration @ImportResource("classpath:c