JavaEE学习笔记之SSH—Spring(1)

曾经终败给现在 2022-07-21 11:16 191阅读 0赞

**一、Spring相关概念**

1:轻量级的容器:

容器:spring容器帮我们管理业务逻辑层,里边有很多业务逻辑对象,有对象就有对象的生命周期的管理(创建,销毁).

轻量级:容器给予的业务逻辑对象多少种服务？spring给用户提供的服务完全由用户自己决定,spring想用什么服务自己开启使用。但是重量级的都是只要你用就把所有的服务都给你,不能自己定制。

spring容器从来不能独立运行,一定借助于其他容器启动,或者借助web容器启动,或者ejb容器启动。

**特点:**  
应用模块之间耦合度小,组件都是可重用的,都是各自打包的

**二、why spring？**

1)动态解藕,方便开发,面向接口设计

通过Spring提供的IoC容器,我们可以将对象之间的依赖关系交由Spring进行控制,避免硬编码所造成的过度程序耦合。有了Spring,用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码,可以更专注于上层的应用

2)方便程序的测试TDD(Test-Driven Development)

可以用非容器依赖的编程方式进行几乎所有的测试工作,在Spring里,测试不再是昂贵的操作,而是随手可做的事情。

3)降低Java EE API的使用难度

Spring对很多难用的Java EE API(如JDBC,JavaMail,远程调用等)提供了一个简单的封装层,通过Spring的简易封装,这些Java EE API的使用难度大为降低。

4)方便集成各种优秀框架

Spring不排斥各种优秀的开源框架,相反,Spring可以降低各种框架的使用难度,Spring提供了对各种优秀框架(如Struts,Hibernate、Hessian、Quartz)等的直接支持。

5)AOP编程的支持

通过Spring提供的AOP功能,方便进行面向切面的编程,许多不容易用传统OOP（Object Oriented Programming）实现的功能可以通过AOP轻松应付。

6)声明式事务的支持

在Spring中,我们可以从单调烦闷的事务管理代码中解脱出来,通过声明式方式灵活地进行事务的管理,提高开发效率和质量。

7)对异常的处理方式,所有的都转换成Unchecked的。

8)它不是一个一体化的解决方案。

9)良好的设计,容易扩展,很多可重用的组件

**优点:**

1:开发人员可以只关注整个结构中的其中某一层；
    
    2:可以很容易的用新的实现来替换原有层次的实现；
    
    3:可以降低层与层之间的依赖；
    
    4:有利于标准化；
    
    5:利于各层逻辑的复用。.
    
    6:结构更加的明确
    
    7:在后期维护的时候,极大地降低了维护成本和维护时间

**缺点:**

1:降低了系统的性能。这是不言而喻的。如果不采用分层式结构,很多业务可以直接造访数据库,以此获取相应的数据,如今却必须通过中间层来完成。
    
    2:有时会导致级联的修改。这种修改尤其体现在自上而下的方向。如果在表示层中需要增加一个功能,为保证其设计符合分层式结构,可能需要在相应的业务逻辑层和数据访问层中都增加相应的代码。
    
    3:增加了开发成本。

**spring框架结构**

![这里写图片描述][20160714184557188]

Spring 框架是一个分层架构，它包含一系列的功能要素，并被分为大约20个模块。这些模块分为Core Container、Data Access/Integration、Web、AOP（Aspect Oriented Programming）、Instrumentation和测试部分，如目录中所带图所示：

Core Container ：

Core Container(核心容器):包含有Core、Beans、Context和Expression Language模块。
    
    
    
    Core和Beans模块：框架的基础部分，提供IoC(反转控制)和依赖注入特性。这里的基础概念是BeanFactory，它提供对Factory模式的经典实现来消除对程序性单例模式的需要，并真正的允许你从程序逻辑中分离出依赖关系和配置。
    
    
    
    Context模块：构建于Core和Beans模块基础之上，提供了一种类似于JNDI注册器的框架式的对象访问方法。Context模块继承了Beans的特性，然后添加了对国际化(例如资源绑定)、事件传播、资源加载和对Context的透明创建的支持。Context模块同时也支持J2EE的一些特性，例如EJB、JMX和基础的远程处理。ApplicationContext接口是Context模块的关键。
    
    
    
    Expression Language模块：Expression Language模块提供了一个强大的表达式语言用于在运行时查询和操纵对象。它是JSP2.1规范中定义的unifed expression language的一个扩展。该语言支持设置/获取属性的值、属性的分配、方法的调用、访问数组上下文（accessiong the context of arrays）、容器和索引器、逻辑和算术运算符、命名变量以及从Spring的IoC容器中根据名称检索对象。它也支持list投影、选择和一般的list聚合。

Data Access/Integration :数据访问/集成部分

Data Access/Integration层包含有JDBC、ORM、OXM、JMS和Transaction模块。
    
    
    
    JDBC模块：该模块提供了一个JDBC抽象层，它可以消除冗长的JDBC编码和解析数据库厂商特有的错误代码。
    
    ORM模块：该模块为流行的对象-关系映射API——JPA、JDO、Hibernate、iBatis等提供了一个交互层。利用ORM封装包，可以混合使用所有Spring提供的特性进行O/R映射。如前边提到的简单声明性事物管理。
    
    OXM模块：该模块提供了一个对Object/XML映射实现的抽象层，Object/XML映射实现包括JAXB、Castor、XMLBeans、JiBX和XStream。
    
    JMS模块：JMS(Java Messaging Service)模块主要包含了一些制造和消费消息的特性。
    
    Transaction模块：该模块支持编程和声明性的事物管理，这些事物类必须实现特定的接口，并且对所有的POJO都适用。

Web ：

Web层包含了Web、Web-Servlet、Web-Struts、Web-Porlet模块。
    
    
    
    Web模块：该模块提供了基础的面向web的集成特性。例如多文件上传、使用servlet listeners初始化IoC容器以及一个面向web的应用上下文。它还包含Spring远程支持中web相关部分。
    
    
    
    Web-Servlet模块：该模块包含Spring的model-view-controller（MVC）实现。Spring的MVC框架使得模型范围内的代码和web forms之间能够清楚的分离开来，并与Spring框架的其他特性集成在一起。
    
    Web-Struts模块：该模块提供了对Struts的支持，使得类在Spring应用中能够与一个典型的Struts web层集成在一起。注意，该支持在Spring 3.0中是deprecated的。
    
    Web-Porlet模块：提供了用于portlet环境和Web-Servlet模块的MVC的实现。

AOP和Instrumentation

AOP模块提供了一个符合AOP联盟标准的面向切面编程的实现，它让你可以定义，例如方法拦截器和切点，从而将逻辑代码分开，降低它们之间的耦合性。利用source-level的元数据功能，还可以将各种行为信息合并到你的代码中，这有点像.net中的attribute的概念。
    
    
    
    Aspects模块提供了对AspectJ的集成支持。
    
    
    
    Instrumentation模块提供了class instrumentation支持和classloader实现，使得可以在特定的应用服务器上使用。

Test

Test模块支持使用JUnit和TestNG对Spring组件进行测试。

**三、Spring核心组件(我们主要学习的是IOC和AOP模块)**

(1)、Spring Core(IOC) 核心容器,提供组件的创建、装备、销毁

(2)、Spring Context Spring上下文,是一个接口ApplicationContext(继承自BeanFactory接口)的实现

(3)、Spring Web容器,web应用上下文,是webApplicationContext接口的实现

(4)、Spring DAO容器,是SpringDAO 支持模块,是为了简化DAO的使用

(5)、Spring ORM

(6)、Spring AOP ,对AOP编程支持的模块

(7)、Spring MVC,类似于Spring表示层的一个框架

**那么现在就来搭建 Spring 框架（相对于前两个框架来说 Spring 框架更容易配置）：**

1)获得发布包

第一种，简单粗暴直接

[http://repo.springsource.org/libs-release-local/org/springframework/spring/3.2.4.RELEASE/spring-framework-3.2.4.RELEASE-dist.zip][http_repo.springsource.org_libs-release-local_org_springframework_spring_3.2.4.RELEASE_spring-framework-3.2.4.RELEASE-dist.zip]

直接粘到地址栏或者下载工具里，每次有更新只要改版本号就可以；

第二种

[http://repo.springsource.org/libs-release-local/][http_repo.springsource.org_libs-release-local]

把这个粘到地址栏里，你会看到一个树型目录，然后就是一级一级往下点了；

第三种

你要在官网的projects里找到spring framework，然后点猫，跳到github，在Downloading artifacts下面找到 building a distribution with dependencies的超链，进去后再找到 the SpringSource repository的超链，接着打开Spring repository FAQ后，找到libs-release-local，进去后点Artifacts页签，再在左边的列表里先simple brower，后面的流程和第二步一样。

spring官网:[http://spring.io][http_spring.io]

也可以用下面的这个地址,显示出列表

[http://repo.spring.io/libs-release/org/springframework/spring/][http_repo.spring.io_libs-release_org_springframework_spring]

2）导入相应 jar 包

在 Spring 中有很多 jar 包，但是一般的好多 jar 包都基本上用不到。只需要导入要用的 jar 包即可。

需要用的 jar 包：

![这里写图片描述][20160714184539542]  
这样就配置好了。

**四、spring ioc(must):**

IOC:Inversion of Control 控制反转

一种说法:对象之间的依赖关系,由容器在运行时依据配置文件动态的建立
       另一种说法:对象的控制器转移了,转到外部容器了,避免了代码的纠缠,代码更容易被维护,模板之间的耦合性降低,容易测试

IoC 控制反转意味着将你设计好的类交给容器去控制,而不是在类的内部进行控制,即控制权由应用代码中转到了外部容器

IoC:包括两部分内容

DI:Dependency Injection依赖注入,组件不做定位查询,只提供相应方法,由容器创建对象,并调用相应方法设置所需对象需要的组件
      (不要求)DL:Dependency Loopup依赖查找,容器创建对象并提供回调接口和上下文环境给组件,需要时通过接口从容器中查找对象
    依赖查找,现在使用不太多。(EJB使用的更多,将对象创建好后,放到容器中。)

IOC解决:对象谁来创建的问题

DI解决:对象间的关系如何建立的问题。

org.springframework.beans及org.springframework.context包是IOC容器的基础

**五、SpringIOC核心api**

**BeanFactory接口和容器**

BeanFactory是Spring中Bean容器,IoC的核心接口,主要用于处理Bean的初始化和配置,建立对象间的依赖关系

定义了如下方法:

Object getBean(String name) //根据指定名称返回一个Bean实例
    
       <T> T getBean(Class<T> requiredType)  
                                  //返回一个与给定Class唯一匹配的Bean实例
    
       <T> T getBean(String name, Class<T> requiredType)
    
       Object getBean(String name, Object... args)
    
       Class<?> getType(String name)       //得到名称为name的Bean的Class对象
    
       boolean isPrototype(String name)   //判断名称为name的Bean是否是原型,
                                              即是否总是返回一个新实例
       boolean isSingleton(String name)   //判断名称为name的Bean是否是单例
    
       boolean containsBean(String name)  //判断是否包含给定名称的Bean实例
    
       boolean isTypeMatch(String name, Class<?> targetType)
                             //判断名称为name的Bean实例是否为targetType类型
       String[] getAliases(String name)  //如果名称为name的Bean有别名返回

通过getBean方法便可以得到相应的类实例,但是最好永远不调用,而使用注入,避免对Spring API的依赖

在Spring中,同一Spring容器中的bean默认情况下是Singleton(单例),将在bean的作用域介绍.

**ApplicationContext接口**

该接口继承于BeanFactory,增强了BeanFactory,提供了事务处理AOP,国际化,事件传递

所以在代码中我们一般会使用ApplicationContext接口,以及这个接口相应的实现类来创建spring的容器对象。

例如:
    String path = "com/briup/ioc/set/set.xml";
    ApplicationContext container = new ClassPathXmlApplicationContext(path);

=================================================

六、配置文件

Spring通过读取配置文件中的数据来对应用中各个对象进行实例化,配置以及组装,通常使用XML文件来作为配置文件。

XML基本结构如下:

<?xml version="1.0" encoding="UTF-8"?>
        <beans xmlns="http://www.springframework.org/schema/beans" 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-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">
    
        </beans>

这个文件的头部声明可以在下载的spring文档中的示例找到.注意这里面用到了两个schema文件(.xsd文件),就是spring-beans-3.2.xsd和spring-context-3.2.xsd,这两个文件在下载的spring文档中也是可以找到的.我们在Eclipse中把xml文件和schema文件关联后,在这个xml中就可以有智能提示了。这和Struts2中tdt文件的关联很相似的。

还有一点需要注意,将来我们这xml中再引入另外的schema文件后在配置的时候就可以智能提示出新的配置内容,spring是有很多模块组成的,我们需要什么功能的配置标签就需要引入对应的schema文件,从而获得智能提示,同时也能帮我们验证配置的正确性。

**七、IOC注入**

接下来了解下 IOC 注入的几种方式：

**1)set方式注入(必须依靠set方法)**  
可以注入的内容有:

A、基本类型(8中基本类型+字符串)的装配
      B、对象类型的装配
      C、集合的装配

A、基本类型的装配  
方式: 配置元素 `<value/>`  
例子:

public class HelloBean {
            private String name;
            private int age;
            public String sayHello(){
                return "hello "+name +",your age is" + age;
            }
            .............
        }

配置文件set.xml

测试类:

main:
            ApplicationContext ac = 
                new ClassPathXmlApplicationContext("set.xml");
            //获取容器的一个实例
            HelloBean hb = (HelloBean) ac.getBean("helloBean");
            System.out.println(hb.sayHello());

B、对象类型的装配  
(1)、`<ref local=" "/>` 用于涉及的对象的id在当前配置文件中(用于在本配置文件中配置了的bean的引入同ref=”..”)  
(2)、`<ref bean=" "/>` 用于涉及的对象的id不在本配置文件中  
(用于引用不在本配置文件中配置的bean)  
(3)、使用property的ref属性引用

public class OtherBean {
            private String str1;
            public String getStr1() {
                return str1;
            }
            public void setStr1(String str1) {
                this.str1 = str1;
            }
            public String toString(){
                return "OtherBean "+str1;
            }
        }
    
        public class SomeBean {
            private OtherBean ob;
            public void printInfo(){
                System.out.println("someBean "+ob);
            }
            public OtherBean getOb() {
                return ob;
            }
            public void setOb(OtherBean ob) {
                this.ob = ob;
            }
        }

配置applicationContext.xml

配置other.xml文件

<bean id="otherBean" class="ioc.OtherBean">
            <property name="str1">
                <value>string1</value>
            </property>
        </bean>

测试类:

main:
            String[] path = {
       "ioc/applicationContext.xml","ioc/other.xml"};
            ApplicationContext ac = new ClassPathXmlApplicationContext(path);
            SomeBean sb = (SomeBean) ac.getBean("someBean");
            sb.printInfo();

C、集合的装配  
方式:配置元素`<list> <set> <map> <props>`

public class SomeBean {
            private List listProperty;
            private Set setProperty;
            private Map mapProperty;
            private Properties<String,String> property;
            public List getListProperty() {
                return listProperty;
            }
            public void setListProperty(List listProperty) {
                this.listProperty = listProperty;
            }
            public Set getSetProperty() {
                return setProperty;
            }
            public void setSetProperty(Set setProperty) {
                this.setProperty = setProperty;
            }
            public Map getMapProperty() {
                return mapProperty;
            }
            public void setMapProperty(Map mapProperty) {
                this.mapProperty = mapProperty;
            }
            public Properties getProperty() {
                return property;
            }
            public void setProperty(Properties property) {
                this.property = property;
            }
            public void printInfo(){
                System.out.println("listProperty");
                System.out.println(listProperty);
                System.out.println("setProperty");
                System.out.println(setProperty);
                Set set = mapProperty.entrySet();
                Iterator it = set.iterator();
                while(it.hasNext()){
                     Map.Entry entry = (Entry) it.next();
                     System.out.println("Key " +entry.getKey() );
                     System.out.println("value "+entry.getValue());
                }
                System.out.println("props: ");
                Set set2 = property.entrySet();
                Iterator it2 = set2.iterator();
                while(it2.hasNext()){
                    Map.Entry entry= (Entry) it2.next();
                    System.out.println("key "+entry.getKey());
                    System.out.println("value "+entry.getValue());
                }
            }
        }

applcationContext.xml的写法:

<bean id="someBean" class="ioc.SomeBean">
            <property name="listProperty">
                 <list>
                    <value>list1</value>
                    <value>list1</value>
                    <value>list3</value>
                 </list>
            </property>
            <property name="setProperty">
                 <set>
                    <value>set1</value>
                    <value>set1</value>
                    <value>set3</value>
                 </set>
            </property>
            <property name="mapProperty">
                 <map>
                    <entry key="key1">
                      <value>value1</value>
                    </entry>
                    <entry key="key2">
                      <value>value2</value>
                    </entry>
                 </map>
            </property>
            <property name="property">
                 <props>
                  <prop key="key1">prop1</prop>
                  <prop key="key2">prop2</prop>
                  <prop key="key3">prop3</prop>
                 </props>
            </property>
        </bean>

测试类:

main:
            String path = "ioc/applicationContext.xml";
            ApplicationContext  ac =
                new ClassPathXmlApplicationContext(path);
            SomeBean sb = (SomeBean) ac.getBean("someBean");
            sb.printInfo();

**2)基于构造器注入**  
方式: 配置`<constructor-arg>`元素  
在Bean中不用写set方法,但是要有相应的构造器

构造器注入有两种形式 一个是根据参数类型 一个是根据参数位置的下标

<constructor-arg type="int" value=""> <constructor-arg index="0" value="">

例如:

或者:

**3)自动注入 :容器依照一些规则去装配bean中的一个属性**  
注意:自动装配只对\[对象类型\]起作用,对基本类型不起作用.

第一种情况:
      在beans标签中配置装载方式:default-autowire="byName"
      default-autowire="byName"
            在根元素beans中加入这个属性,那么下面所有的bean都会
            使用byName的方式进行自动注入,如果在下面的某一个bean
            里面想使用其他的方式进行注入,可以用autowire=""属性进行
            说明,或者某一个bean不想使用任何自动注入就使用autowire="no"
    
      第二种情况:
      在bean标签中指定配置方式
      autowire="byName":
            spring容器会到当前的类中找property的名字,然后
            再根据这个名字去spring容器中找有没有和这个property
            名字相同的对象,有的话,就把这个对象当做参数放到
            setXxxx这个方法里面注入进来.
            注意:了解property指的类中的什么东西。
    
      autowire="byType":
            spring容器会根据当前类中的set方法里面参数的类型,
            去容器中找相匹配的对象,如果没找到就算了,如果找到
            一个就注入进来,如果找到多个,那么就会报错了.
    
      autoWrite="constructor" 
        根据构造器的参数类型去匹配

**4)继承:并不是oo的继承关系**  
bean的定义的继承,指bean的配置可去继承

abstract =  
               true 抽象化 代码中不能getBean获取其对象       false 默认
    
      parent = "父类bean的id/name"
    
      例子:

<bean name="student" class="com.briup.bean.Student">
            <property name="name">
                <value>zhangsan</value>
            </property>
        </bean>
    
        
    
        <bean name="teacher" class="com.briup.bean.Teacher" abstract="true">
            <property name="student" ref="student"></property>
        </bean>
    
        
    
        <bean name="t" parent="teacher">
    
            <property name="id">
                <value>11</value>
            </property>
    
            <property name="name">
                <value>TeacherWang</value>
            </property>
        </bean>

[20160714184557188]: /images/20220720/64b00322869449eb98aaf180bf513ba0.png
[http_repo.springsource.org_libs-release-local_org_springframework_spring_3.2.4.RELEASE_spring-framework-3.2.4.RELEASE-dist.zip]: http://repo.springsource.org/libs-release-local/org/springframework/spring/3.2.4.RELEASE/spring-framework-3.2.4.RELEASE-dist.zip
[http_repo.springsource.org_libs-release-local]: http://repo.springsource.org/libs-release-local/
[http_spring.io]: http://spring.io
[http_repo.spring.io_libs-release_org_springframework_spring]: http://repo.spring.io/libs-release/org/springframework/spring/
[20160714184539542]: /images/20220720/12a231bf88be4c0f83392b0ca085ef77.png