Spring入门与常用配置

什么是Spring

Spring：SE/EE开发的一站式框架。

一站式框架：有EE开发的每一层解决方案。

　　　　 WEB层：SpringMVC

　　　　 Service层：Spring的Bean管理，Spring声明式事务

　　　　 DAO层：Spring的Jdbc模板，Spring的ORM模块

为什么学习Spring

Spring的入门（IOC）

什么IOC？

IOC: Inversion of Control(控制反转)。

　　控制反转：将对象的创建权反转给（交给）Spring。

下载Spring的开发包

官网:http://spring.io/

docs ：Spring的开发规范和API

libs ：Spring的开发的jar和源码

schema ：Spring的配置文件的约束

创建web项目，引入jar包

创建接口和类

问题：如果底层的实现切换了，需要修改源代码，能不能不修改程序源代码对程序进行扩展？

将实现类交给Spring管理

在spring的解压路径下spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configuration.html

编写测试类

编写userDAO和userDAOImp

userDAO

public interface userDAO {
    public void save();
}

userDAOImp

public class userDAOImp implements userDAO {
    @Override
    public void save() {
        System.out.println("userDAOImp执行了......");
    }
}

设置spring的xml applicationContext.xml 可以随意命名

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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">
<!--spring入门的配置-->
    <bean id="userDAO" class="spring.learn.userDAOImp">
    
    </bean>
</beans>

最后编写SpringDemo1对功能进行实现

package spring.learn;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringDemo1 {
    //传统的调用方式
    public void demo1(){
        userDAO userDAO=new userDAOImp();
        userDAO.save();
    }
    //Spring的方式的调用
    public void demo2(){
        //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        userDAO userDAO=(userDAO)applicationContext.getBean("userDAO");
        userDAO.save();
    }

    public static void main(String[] args) {
        SpringDemo1 springDemo1=new SpringDemo1();
        springDemo1.demo1();
        springDemo1.demo2();
    }
}

结果显示

IOC和DI（*****）

IOC：控制反转，将对象的创建权反转给了Spring。
DI：依赖注入，前提必须有IOC的环境，Spring管理这个类的时候将类的依赖的属性注入（设置）进来。
面向对象的时候
依赖
Class A{

}

Class B{
    public void xxx(A a){

}
}
继承:is a
Class A{

}
Class B extends A{

}

Spring的工厂类

Spring工厂类的结构图

ApplicationContext继承BeanFactory

　　　　BeanFactory：老版本的工厂类 BeanFactory：调用getBean的时候，才会生成类的实例。

ApplicationContext：新版本的工厂类

ApplicationContext：加载配置文件的时候，就会将Spring管理的类都实例化。

ApplicationContext有两个实现类

ClassPathXmlApplicationContext：加载类路径下的配置文件

FileSystemXmlApplicationContext ：加载文件系统下的配置文件

Bean的相关配置

<bean>标签的id和name的配置

　　id :使用了约束中的唯一约束。里面不能出现特殊字符的。

name :没有使用约束中的唯一约束（理论上可以出现重复的，但是实际开发不能出现的）。里面可以出现特殊字符。

Spring和Struts1框架整合的时候

1Bean的生命周期的配置（了解）

init-method :Bean被初始化的时候执行的方法

destroy-method :Bean被销毁的时候执行的方法（Bean是单例创建，工厂关闭）

Bean的作用范围的配置（重点）

scope :Bean的作用范围

singleton：默认的，Spring会采用单例模式创建这个对象。
prototype：多例模式。（Struts2和Spring整合一定会用到）
request ：应用在web项目中，Spring创建这个类以后，将这个类存入到request范围中。
session ：应用在web项目中，Spring创建这个类以后，将这个类存入到session范围中。
globalsession ：应用在web项目中，必须在porlet环境下使用。但是如果没有这种环境，相对于session

Spring的Bean实例化方式（了解）

Bean已经都交给Spring管理，Spring创建这些类的时候，有几种方式：

无参构造的方式（默认）

编写无参构造类

public class Bean1 {
    public Bean1(){
        System.out.println("Bean1的无参构造方法执行了......");
    }
}

<!--配置无参构造方法-->
    <bean id="bean1" class="spring.learn.demo1.Bean1"></bean>

实现功能

public class SpringDemo1 {
    public static void main(String[] args) {
        //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        Bean1 bean1=(Bean1) applicationContext.getBean("bean1");
    }
}

静态工厂实例化方式

配置

实例工厂实例化的方式

配置

Spring的属性注入

构造方法属性注入

编写类

public class Car {
    public String name;
    public double price;
    public Car(String name,double price){
        this.name=name;
        this.price=price;
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

 <!--构造方法的方式注入-->
    <bean id="car" class="spring.learn.demo2.Car">
        <constructor-arg name="name" value="宝马" />
        <constructor-arg name="price" value="800000" />
    </bean>

实现

public class SpringDemo2 {
    public static void main(String[] args) {
        //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        Car car=(Car)applicationContext.getBean("car");
        System.out.println(car.toString());
    }
}

set方法方式的属性注入

public class Car2 {
    public String name;
    public double price;

    public void setName(String name) {
        this.name = name;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Car2{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

配置

<!--Set方法的方式的属性注入-->
    <bean id="car2" class="spring.learn.demo2.Car2">
        <property name="name" value="奔驰" />
        <property name="price" value="10000000000" />
    </bean>

实现方式

public class SpringDemo2 {
    public static void main(String[] args) {
        //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        Car2 car2=(Car2)applicationContext.getBean("car2");
        System.out.println(car2.toString());
    }
}

set方法设置对象类型的属性

public class Employee {
    public String name;
    public Car2 car2;

    public void setName(String name) {
        this.name = name;
    }

    public void setCar2(Car2 car2) {
        this.car2 = car2;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", car2=" + car2 +
                '}';
    }
}

配置

<!--Set方法的方式的属性注入-->
    <bean id="car2" class="spring.learn.demo2.Car2">
        <property name="name" value="奔驰" />
        <property name="price" value="10000000000" />
    </bean>

    <!--Set方法设置对象类型的属性-->
    <bean id="employee" class="spring.learn.demo2.Employee">
        <!--Value:设置普通类型的值，ref设置其他类的id或者name-->
        <property name="name" value="zyz" />
        <property name="car2" ref="car2" />
    </bean>

实现

public class SpringDemo3 {
    public static void main(String[] args) {
        //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        Employee employee=(Employee)applicationContext.getBean("employee");
        System.out.println(employee.toString());
    }
}

P名称空间的属性注入（Spring2.5以后）

　　　　通过引入p名称空间完成属性的注入：

　　　　　　写法：

　　　　　　　　普通属性 p:属性名=”值”

　　　　　　　　对象属性 p:属性名-ref=”值

p名称空间的引入

使用p名称空间

SpEL的属性注入（Spring3.0以后）

SpEL：Spring Expression Language，Spring的表达式语言。

集合类型属性注入（了解）

import java.util.Arrays;

public class CollectionBean {
    public String arr[];
    public void setArr(String[] arr) {
        this.arr = arr;
    }
    @Override
    public String toString() {
        return "CollectionBean{" +
                "arr=" + Arrays.toString(arr) +
                '}';
    }
}

<!--注入数组类型-->
    <bean id="collectionBean" class="spring.learn.demo2.CollectionBean">
        <!--数组类型的-->
        <property name="arr">
            <list>
                <value>王东</value>
                <value>赵洪</value>
                <value>李冠希</value>
            </list>
        </property>
    </bean>

public void arrdemo1(){
        //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        CollectionBean collectionBean=(CollectionBean)applicationContext.getBean("collectionBean");
        System.out.println(collectionBean.toString());
    }

import java.util.List;

public class ListBean {
    public List list;
    public void setList(List list) {
        this.list = list;
    }
    @Override
    public String toString() {
        return "ListBean{" +
                "list=" + list +
                '}';
    }
}

<!--注入list集合-->
    <bean id="listBean" class="spring.learn.demo2.ListBean">
        <property name="list">
            <list>
                <value>王东</value>
                <value>赵洪</value>
                <value>李冠希</value>
            </list>
        </property>
    </bean>

public void listdemo1(){
        //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        ListBean listBean=(ListBean)applicationContext.getBean("listBean");
        System.out.println(listBean.toString());
    }

注入Set集合

import java.util.Set;

public class SetBean {
    public Set set;

    public void setSet(Set set) {
        this.set = set;
    }
    @Override
    public String toString() {
        return "SetBean{" +
                "set=" + set +
                '}';
    }
}

<!--注入Set集合-->
    <bean id="setBean" class="spring.learn.demo2.SetBean">
        <property name="set">
            <set>
                <value>aaa</value>
                <value>bbb</value>
                <value>ccc</value>
            </set>
        </property>
    </bean>

public void setdemo1(){
        //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        SetBean setBean=(SetBean)applicationContext.getBean("setBean");
        System.out.println(setBean.toString());
    }

注入Map集合

import java.util.Map;

public class MapBean {
    public Map map;
    public void setMap(Map map) {
        this.map = map;
    }

    @Override
    public String toString() {
        return "MapBean{" +
                "map=" + map +
                '}';
    }
}

<!--注入Map集合-->
    <bean id="mapBean" class="spring.learn.demo2.MapBean">
        <property name="map">
            <map>
                <entry key="aaa" value="111"/>
                <entry key="bbb" value="222"/>
                <entry key="ccc" value="333"/>
            </map>
        </property>
    </bean>

public void mapdemo1(){
        //创建Spring的工厂
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        MapBean mapBean=(MapBean)applicationContext.getBean("mapBean");
        System.out.println(mapBean.toString());
    }

Spring的分模块开发的配置

在加载配置文件的时候，加载多个

在一个配置文件中引入多个配置文件

posted @ 2019-09-25 22:39 薄眠抛却陈年事。阅读(318) 评论(0) 编辑收藏举报

刷新页面返回顶部

莫道长安花看尽

一纸高中万里风，寒窗读破华堂空。莫道长安花看尽，由来枝叶几相同？

Spring入门与常用配置

什么是Spring

公告

莫道长安花看尽

一纸高中万里风， 寒窗读破华堂空。 莫道长安花看尽， 由来枝叶几相同？

Spring入门与常用配置

什么是Spring

公告

一纸高中万里风，寒窗读破华堂空。莫道长安花看尽，由来枝叶几相同？