spring

最新推荐文章于 2024-02-19 09:51:20 发布

qq_31743965

最新推荐文章于 2024-02-19 09:51:20 发布

阅读量223

点赞数

分类专栏： java spring 文章标签： spring 开源框架 ioc 第一行代码

本文链接：https://blog.csdn.net/qq_31743965/article/details/78739868

版权

java 同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

spring

1 篇文章 0 订阅

订阅专栏

一．SPRING介绍

Spring 是什么：
1.Spring 是一个开源框架.
2.Spring 为简化企业级应用开发而生. 使用 Spring 可以使简单的 JavaBean 实现以前只有 EJB 才能实现的功能.
3.Spring 是一个 IOC(DI)
4.Spring 是一个AOP 容器框架.
5.Spring 是一个粘合剂（用于整合各种框架）
具体描述 Spring:
1.轻量级：Spring 是非侵入性的 - 基于 Spring 开发的应用中的对象可以不依赖于 Spring 的 API
2.依赖注入(DI — dependency injection、IOC—- Inversion of Control)
3.面向切面编程(AOP — aspect oriented programming)
4.容器: Spring 是一个容器, 因为它包含并且管理应用对象的生命周期
5.框架: Spring 实现了使用简单的组件配置组合成一个复杂的应用. 在 Spring 中可以使用 XML 和 Java 注解组合这些对象
6.一站式：在 IOC 和 AOP 的基础上可以整合各种企业应用的开源框架和优秀的第三方类库（实际上 Spring 自身也提供了展现层的 SpringMVC 和持久层的 Spring JDBC,spring boot,spring clound）

Spring体系结构:
http://maven.springframework.org/release/org/springframework/spring
下载doc,schema,jar包

https://github.com/spring-projects/spring-framework/tags
下载源码代码

这里写图片描述

二、搭建 Spring 开发环境：

1．不使用spring框架如何处理
2．使用spring框架如何处理
1）所需要的jar包

这里写图片描述

2）编写java类

3）编写applicationContext.xml
Spring 的配置文件: 一个 Spring 项目需要创建一个或多个 Bean 配置文件, 这些配置文件用于在 Spring IOC 容器里配置 Bean。Bean 的配置文件可以放在 classpath 下, 也可以放在其它目录下，一般放在classpath目录下。

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

    <bean id="helloWorld" class="com.softjx.service.HelloWorld">    
    <property name="userName">
       <value>pkd</value>
    </property> 
    </bean> 

</beans>

4）编写测试类

//spring容器初始化
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");

        HelloWorld hw=(HelloWorld)context.getBean("helloWorld"); //对象是有spring容器创建，客户端直接拿来使用，思想叫做IOC,反转控制


        hw.hello();


三．IOC(DI)分析一
------------
1.客户端调用的多种写法

    //spring容器初始化
    ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");

    //HelloWorld hw=(HelloWorld)context.getBean("helloWorld");

    // HelloWorld hw=context.getBean(HelloWorld.class); 

   HelloWorld hw=context.getBean("helloWorld11", HelloWorld.class);


    hw.hello();

2.为什么叫IOC,分析对象的构建过程
对象的的构建是spring容器，默认是调用类的默认构造函数。如果不编写自定义的构造函数，spring容器调用类的默认构造函数，如果编写自定义的构造函数，一定要重写类的默认构造函数。

public HelloWorld() {
System.out.println(“HelloWorld 构建”);

}
public HelloWorld(String userName) {
this.userName = userName;
System.out.println(“HelloWorld 构建自定义”);
}


四．IOC(DI)分析二
------------
Spring 支持 3 种依赖注入的方式 
**1）属性注入** 

属性注入即通过 setter 方法注入Bean 的属性值或依赖的对象 ，
属性注入使用 `<property> `元素, 使用 name 属性指定 Bean 的属性名称，value 属性或 `<value>` 子节点指定属性值 ，属性注入是实际应用中最常用的注入方式 。
a.非引用注入`(String,int,float ,doube,Boolean,char,long,short,byte)`

<bean id="helloWorld" class="com.softjx.service.HelloWorld" >

    <property name="userName">
       <value>pkd</value>
    </property> 

    <property name="age" value="21"></property>

    <property name="salary" value="4567.00"></property>

    </bean>
**b.应用注入（javabean）**
组成应用程序的 Bean 经常需要相互协作以完成应用程序的功能. 要使 Bean 能够相互访问, 就必须在 Bean 配置文件中指定对 Bean 的引用；
![这里写图片描述](http://img.blog.csdn.net/20171207204758493?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvcXFfMzE3NDM5NjU=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
**2）构造器注入** 

通过构造方法注入Bean 的属性值或依赖的对象，它保证了 Bean 实例在实例化后就可以使用。构造器注入在 `<constructor-arg>` 元素里声明属性。
c.非引用注入`(String,int,float ,doube,Boolean,char,long,short,byte)`

    <bean id="book1" class="com.softjx.service2.Book">      
     <constructor-arg name="bookName" value="java" />
    </bean>

d.引用注入（javabean）
在 Bean 的配置文件中, 可以通过<ref> 元素或 ref 属性为 Bean 的属性或构造器参数指定对 Bean 的引用.也可以在属性或构造器里包含 Bean 的声明, 这样的 Bean 称为内部 Bean

<bean id="student1" class="com.softjx.service2.Student">
    <constructor-arg ref="book2" />
    </bean>

3）集合属性注入

在 Spring中可以通过一组内置的 xml 标签(例如:数组，<list>, <set> 或 <map>，Properties) 来配置集合属性；
配置 java.util.List 类型的属性, 需要指定<list> 标签, 在标签里包含一些元素. 这些标签可以通过 <value> 指定简单的常量值, 通过 <ref>指定对其他 Bean 的引用. 通过<bean> 指定内置 Bean 定义. 通过<null/> 指定空元素. 甚至可以内嵌其他集合；
数组的定义和 List 一样, 都使用 <list>配置 java.util.Set 需要使用 <set> 标签, 定义元素的方法与 List 一样；
Java.util.Map 通过 <map> 标签定义,<map> 标签里可以使用多个 <entry> 作为子标签. 每个条目包含一个键和一个值；
必须在 <key> 标签里定义键，因为键和值的类型没有限制, 所以可以自由地为它们指定 <value>, <ref>, <bean>或 <null>元素；
可以将 Map 的键和值作为<entry> 的属性定义: 简单常量使用 key 和 value 来定义; Bean 引用通过 key-ref 和 value-ref 属性定义；

使用 <props>定义 java.util.Properties, 该标签使用多个<prop> 作为子标签. 每个 <prop> 标签必须定义 key 属性；

    <property name="arrayValue">
        <list>
            <value>array1</value>
            <value>array2</value>
            <value>array3</value>
            <value>array4</value>
        </list>
     </property>  <property name="listValue">
        <list>
            <value>list1</value>
            <value>list2</value>
            <value>list3</value>
            <value>list4</value>
        </list>
     </property> 



      <property name="setValue">
        <set>
            <value>set1</value>
            <value>set2</value>
            <value>set3</value>
            <value>set4</value>
        </set>
     </property>



     <property name="mapValue">
        <map>           
            <entry key="k1" value="value1"/>
            <entry key="k2" value="value2"/>
            <entry key="k3" value="value3"/>
            <entry key="k4" value="value4"/>
        </map>
     </property>



     <property name="basicInfo">
      <props> 
            <!-- 身高 -->  
            <prop key="stature">1.75</prop>  
            <!-- 体重 -->  
            <prop key="avoirdupois">120</prop>  
       </props> 
     </property>

4）时间属性注入

<bean id="dateFormat" class="java.text.SimpleDateFormat">
        <constructor-arg value="yyyy-MM-dd" />
    </bean>   

    <bean id="dateType" class="com.softjx.service.DateType">        

       <property name="dateValue">
            <bean factory-bean="dateFormat" factory-method="parse">
                <constructor-arg value="2016-12-31" />
            </bean>
        </property>

    </bean> 


**5) 内部bean作为注入,没有id名称，不能被外部引用**

a.属性注入

<bean id="student" class="com.softjx.service1.Student"> 
     <property name="book">
       <bean class="com.softjx.service1.Book">
         <property name="bookName"  value="oracle12g"></property>
       </bean>
     </property>
    </bean>

b.构造函数注入

<bean id="student1" class="com.softjx.service2.Student">

    <constructor-arg >
       <bean class="com.softjx.service2.Book">
         <property name="bookName"  value="oracle10g"></property>
       </bean>
    </constructor-arg>

    </bean>

6）集合注入bean

<bean id="book1" class="com.softjx.service3.Book">      
<property name="bookName" value="java"/>
</bean>

 <bean id="book2" class="com.softjx.service3.Book">     
<property name="bookName" value="spring"/>
</bean>

 <bean id="book3" class="com.softjx.service3.Book">     
<property name="bookName" value="oracle11g"/>
</bean>


<bean id="dataTypeAll" class="com.softjx.service3.DataTypeAll">     

     <property name="arrayValue">

        <list>
            <ref bean="book1"/>
            <ref bean="book2"/>
            <ref bean="book3"/>
        </list>

     </property>


      <property name="listValue">
        <list>
            <ref bean="book1"/>
            <ref bean="book2"/>
            <ref bean="book3"/>
        </list>
     </property> 



      <property name="setValue">
        <set>
            <ref bean="book1"/>
            <ref bean="book2"/>
            <ref bean="book3"/>
        </set>
     </property>



     <property name="mapValue">
        <map>           
            <entry key="k1" value-ref="book1" />
            <entry key="k2" value-ref="book2"/>
            <entry key="k3" value-ref="book3"/>

        </map>
     </property>


     <!-- properties key /value 并且是字符型 -->
     <property name="basicInfo">
      <props> 
            <!-- 身高 -->  
            <prop key="stature">book1</prop>  
            <!-- 体重 -->  
            <prop key="avoirdupois">book2</prop>  

       </props> 
     </property>


</bean>

7)工厂方法注入（很少使用，不建议使用，可以了解）
1.通过调用静态工厂方法创建 Bean

调用静态工厂方法创建 Bean是将对象创建的过程封装到静态方法中. 当客户端需要对象时, 只需要简单地调用静态方法, 而不同关心创建对象的细节；
要声明通过静态方法创建的 Bean, 需要在 Bean 的 class 属性里指定拥有该工厂的方法的类, 同时在 factory-method 属性里指定工厂方法的名称.

2.通过调用实例工厂方法创建 Bean
实例工厂方法: 将对象的创建过程封装到另外一个对象实例的方法里. 当客户端需要请求对象时, 只需要简单的调用该实例方法而不需要关心对象的创建细节；
要声明通过实例工厂方法创建的 Bean
在 bean 的 factory-bean 属性里指定拥有该工厂方法的 Bean；
在 factory-method 属性里指定该工厂方法的名称；

3.实现 FactoryBean 接口在 Spring IOC 容器中配置 Bean

Spring 中有两种类型的 Bean, 一种是普通Bean, 另一种是工厂Bean, 即FactoryBean；
工厂 Bean 跟普通Bean不同, 其返回的对象不是指定类的一个实例, 其返回的是该工厂 Bean 的 getObject 方法所返回的对象；