Java之Spring框架

Spring

Spring是什么

Spring是一个一站式的分层结构 轻量级开发框架
可以把Spring理解为对象的管家 帮我们管理项目中用到的对象
其实说白了就是容器(目前最受欢迎的框架)

特点:
    开源
    轻量级(体积小)
    分层架构(按需添加)
    一站式(对目前流行的框架支持非常高)
    IOC
    DI

Spring的作用

    降低复杂性
    松耦性
    高性能
    易测试 Junit
    声明式事务

创建Spring

    1.下载jar包
    2.导入核心包 beans context expression core logging(日志包)
    3.创建编写配置文件
        创建对象交给Spring来管理
    4.创建ApplicationContext容器
    5.通过getBean来获取到对象 如果对象不为空 则Spring搭建成功

创建实例
applicationContext.xml

    
    <bean class="com.lanou.Person" name="person">bean>

测试

    // 想要从容器中获取被管理的对象
    // 1.第一步 创建容器
    ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
    // 2.第二步 从容器中获取bean
    Person p = (Person) ac.getBean("person");
    // 查看是否获取成功
    System.out.println(p);

核心思想

IOC:
    inverse of control 反转控制
    说白了就是把对象的创建反转(交)给Spring来管理
    之前是我们手动new对象 现在是问Spring拿对象
    实现原理:通过反射 + 配置文件
    例如:
        Class c = Class.forName("com.lanou.Person");
        Object o = c.newInstance();
        context.put("person",o);
        context.get("person");

DI技术
    dependency injection
     依赖     注入
     类A中需要B类提供的功能
     称为A依赖B
     例如 Service 依赖 DAO
     UserDao dao = new UserDaoImplForJDBC();
     修改
     UserDao dao = new UserDaoImplForHibernate();

     使用Spring之后
     UserDao dao = context.getBean("UserDaoImpl");
     不需要修改源代码就能实现组件的切换 松耦合

     注入:从外部把需要的对象放到内部就叫注入
     依赖注入最终目的就是提高程序的扩展性 尽可能不去修改源代码

bean的创建方式

1.构造函数创建(默认的)
2.静态工厂创建(调用指定的静态方法获取bean)
3.实例工厂创建(调用实例方法获取bean)

静态工厂创建 和 实例工厂创建
applicationContext.xml

    
    <bean name="person2" class="com.lanou.PersonFactory" factory-method="getPerson">
        <property name="name" value="SC">property>
    bean>

    
    <bean class="com.lanou.PersonFactory" name="personF">bean>    

    
    <bean name="person3" class="com.lanou.PersonFactory" factory-method="getPerson2" factory-bean="personF">
        <property name="name" value="KD">property>
    bean>

PersonFactory

public class PersonFactory {
    // 静态工厂方式创建bean(当我们希望自己创建对象时 使用)
    public static Person getPerson() {
        System.out.println("静态工厂方法RUN");
        return new Person();
    }
    public Person getPerson2() {
        System.out.println("实例工厂方法RUN");
        return new Person();
    }
}

测试

ApplicationContext ac = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
Person p2 = (Person) ac.getBean("person2");
System.out.println(p2);
Person p3 = (Person) ac.getBean("person3");
System.out.println(p3);

注入的四种方式

1.set注入(就是通过set方法 所以必须提供set方法)
2.构造函数注入
3.<:p 命名空间
4.SpEL

set注入

class="com.lanou.Person" name="person">
    -- 
        1.set注入 属性必须提供set方法
        value属性用于注入基础数据类型
        ref属性用于注入引用数组类型
     -->
    <property name="name" value="张三">property>
    <property name="age" value="20">property>
    <property name="car" ref="car">property>


class="com.lanou.Car" name="car">
    <property name="name" value="大众">property>
    <property name="color" value="红色">property>

构造函数注入

<bean name="person4" class="com.lanou.Person">
    
    <constructor-arg name="name" value="100" type="int">constructor-arg>
    <constructor-arg name="age" value="33">constructor-arg>
    <constructor-arg name="car" ref="car" index="0">constructor-arg>
bean>

p命名空间注入

 <bean name="person5" class="com.lanou.Person" p:name="老王" p:age="18" p:car-ref="car">bean>

SpEL注入

<bean name="person6" class="com.lanou.Person" >
    
    <property name="name" value="#{person.name}">property>
    
    <property name="age" value="#{person5.age}">property>
    <property name="car" ref="car">property>
bean>

复杂类型的注入

<bean id="cbean" class="com.lanou.CollectionBean">
    
    <property name="array">
        <array>
            <value>jackvalue>
            <value>rockvalue>
            <value>johnvalue>
        array>
    property>
    
    <property name="list">
        <list>
            <value>大黄蜂value>
            <value>擎天柱value>
            <value>威震天value>
        list>
    property>

    
    <property name="map">
        <map>
        
            <entry key="name" value="王五">entry>
            <entry key="age" value="100">entry>
            
            <entry key="有一个bean" value-ref="abean">entry>
        map>
    property>

    <property name="pop">
        <props>
            <prop key="JDBCDriver">com.mysql.jdbc.Driverprop>
            <prop key="username">rootprop>
            <prop key="password">123456prop>
        props>
    property>

bean>
<bean name="abean" class="com.lanou.CollectionBean">bean>

ApplicationContext两个实现类的区别

ClassPathXMLApplicationContext 用于加载class路径下的配置文件
FileSystemXMLApplicationContext 加载系统路径下的配置文件

写法:
    ApplicationContext ac1 = new ClassPathXmlApplicationContext("beans.xml");
    ApplicationContext ac2 = new FileSystemXmlApplicationContext("file:/Users/lanou/javaweb/sh-spring-01/src/beans.xml");

Spring两种容器

Spring提供两种容器
    1.BeanFactory (已经过时了) 它是Spring框架最古老的接口
        仅定义了实现IOC DI基础功能的接口
        特点:获取bean时才会创建对应的bean   以前的硬件设备资源匮乏
    2.ApplicationContext
        它的功能更加强大
        特点:一旦加载配置文件就全部创建了

Resource resource = new FileSystemResource("/Users/lanou/javaweb/sh-spring-01/src/beans.xml");
BeanFactory  factory = new XmlBeanFactory(resource );
System.out.println("配置加载完成");
System.out.println(factory.getBean("person"));

ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
ac.getBean("person1");
ac.getBean("person1");
ac.getBean("person1");

// 关闭容器 一般不用
// ac.close();

bean元素的属性

scope
    singleton 单例(默认)
    prototype 多例
    request   与request生命周期一致
    session   与session生命周期一致

<bean id="person1" scope="prototype" class="com.lanou.Person">bean>

生命周期的方法

init-method 对象创建完了立即执行
destroy-method 对象销毁前执行

<bean id="person2" class="com.lanou.Person" init-method="init" destroy-method="destroy">    bean>

配置文件的模块化

当一个配置文件内容太多时 可以将其按照功能模块划分
    1.在创建容器时  传入多个字符串对象(配置文件名)
    2.在配置文件中 使用import标签导入

例如:
    ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml","applicationContext.xml");

    
    <import resource="classpath:applicationContext.xml"/>