深入浅出Spring-入门级教程

Spring

简介

Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

优点

• Spring是一个开源的免费的框架（容器）
• Spring是一个轻量级的，非入侵式的框架
• 控制反转（IOC），面向切面编程（AOP）
• 支持事务的处理，对框架整合的支持

总结：Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架！

组成

IOC本质

控制反转是一种设计思想，DI（依赖注入）是实现IOC的一种方法。没有IOC的程序中，我们是用面向对象编程，对象的创建和对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转将对象的创建转移给第三方，个人认为所谓的控制反转就是：获得依赖对象的方式反转了。

IOC创建对象的方式

    <?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="hello" class="com.web.pojo.Hello">
            <property name="name" value="Spring"></property>
        </bean>
    </beans>

    public class MyTest {
        public static void main(String[] args) {
            //获取spring的上下文对象
            ApplicationContext context = new ClassPathXmlApplicationContext(
                    "beans.xml");
            Hello hello = (Hello) context.getBean("hello");
            System.out.println(hello.toString());
        }
    }

Spring的配置

别名

    <!-- 如果添加了别名，我们也可以使用别名获取到这个对象-->
    <alias name="hello" alias="hello2"></alias>

Bean的配置

    <!--
        id：bean的唯一标识，也就是相当于对象名
        class：bean的对象所对应的全限定名：包名+类型
        name：也是别名，而且name可以同时取多个别名
     -->
    <bean id="hello" class="com.web.pojo.Hello" name="hello3,hello4">
        <property name="name" value="Spring"></property>
    </bean>

import

可以将多个配置文件合并为一个

    <import resource="beans2.xml"></import>

依赖注入

    public class Address {
        private String address;
    
        @Override
        public String toString() {
            return "Address{" +
                    "address='" + address + '\'' +
                    '}';
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    }

    public class Student {
    
        private String name;
        private Address address;
        private String[] books;
        private List<String> hobbies;
        private Map<String, String> card;
        private Set<String> games;
        private Properties info;
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", address=" + address.toString() +
                    ", books=" + Arrays.toString(books) +
                    ", hobbies=" + hobbies +
                    ", card=" + card +
                    ", games=" + games +
                    ", info=" + info +
                    '}';
        }
    }

    <?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="address" class="com.pojo.Address">
            <property name="address" value="中国"></property>
        </bean>
    
        <bean id="student" class="com.pojo.Student">
            <!--第一种，普通值注入，value-->
            <property name="name" value="张三"></property>
            <!--第二种，Bean注入，ref-->
            <property name="address" ref="address"></property>
            <!--第三种，数组注入，ref-->
            <property name="books">
                <array>
                    <value>三国演义</value>
                    <value>水浒传</value>
                </array>
            </property>
            <!--第四种，list注入-->
            <property name="hobbies">
                <list>
                    <value>代码</value>
                    <value>听歌</value>
                </list>
            </property>
            <!--第五种，map注入-->
            <property name="card">
                <map>
                    <entry key="身份证" value="123456"></entry>
                    <entry key="手机号" value="78910"></entry>
                </map>
            </property>
            <!--第六种，set注入-->
            <property name="games">
                <set>
                    <value>LOL</value>
                    <value>CF</value>
                    <value>NBA</value>
                </set>
            </property>
            <!--第七种，Properties注入-->
            <property name="info">
                <props>
                    <prop key="学号">2000</prop>
                    <prop key="班级">一班</prop>
                </props>
            </property>
        </bean>
    </beans>

Bean的自动装配

• 自动装配是Spring满足bean依赖的一种方式
• Spring会在上下文中自动寻找，并自动给bean装配属性

在spring中有三种装配方式

• 在xml中显示的配置
• 在java中显示的配置
• 隐式的自动装配bean

        <!--
            byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanId
            byType：会自动在容器上下文中查找，和自己对象属性类型相同的bean
        -->
        <bean id="student" class="com.pojo.Student" autowire="byType"></bean>

注解的自动装配

• @Autowired
  • @Autowired是按类型自动转配的，不支持id匹配。
• @Qualifier
  • @Autowired是根据类型自动装配的，加上@Qualifier则可以根据byName的方式自动装配，其中@Qualifier不能单独使用。
• @Resource
  • @Resource如有指定的name属性，先按该属性进行byName方式查找装配；其次再进行默认的byName方式进行装配；如果以上都不成功，则按byType的方式自动装配。都不成功，则报异常。

小结

@Autowired与@Resource异同：

1° @Autowired与@Resource都可以用来装配bean。都可以写在字段上，或写在setter方法上。

2° @Autowired默认按类型装配（属于spring规范），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false) ，如果我们想使用名称装配可以结合@Qualifier注解进行使用。

3° @Resource（属于J2EE复返），默认按照名称进行装配，名称可以通过name属性进行指定。如果没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，如果注解写在setter方法上默认取属性名进行装配。 当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是，如果name属性一旦指定，就只会按照名称进行装配。它们的作用相同都是用注解方式注入对象，但执行顺序不同。@Autowired先byType，@Resource先byName。

静态代理

角色分析：

• 抽象角色：一般会使用接口或者抽象类来解决
• 真实角色：被代理的角色
• 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
• 客户：访问代理对象的人

代理模式的好处

• 可以使真实角色的操作更加纯粹，不用关注一些公共的业务
• 公共也就是交给代理角色，实现了业务的分工
• 公共业务发生扩展的时候，方便集中管理

缺点：

• 一个真实角色就会产生一个代理角色，代码量翻倍，开发效率变低

动态代理

• 动态代理和静态代理的角色一样
• 动态代理的代理类是动态生成的，不是我们直接写好的
• 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
  • 基于接口—JDK 动态代理
  • 基于类：cglib
  • java字节码实现：javasist

需要了解两个类：Proxy-代理 InvocationHandler-调用处理程序

动态代理的好处：

• 可以使真实角色的操作更加纯粹，不用关注一些公共的业务
• 公共也就是交给代理角色，实现了业务的分工
• 公共业务发生扩展的时候，方便集中管理
• 一个动态代理类代理的是一个接口，一般就是对应的一类业务
• 一个动态代理类可以代理多个类，只要实现了同一个接口即可

    public class ProxyInvocationHandler implements InvocationHandler {
    
        //被代理的接口
        private Object target;
    
        public void setTarget(Object target) {
            this.target = target;
        }
    
        //生成代理类
        public Object getProxy() {
            return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                    target.getClass().getInterfaces(), this);
        }
    
        //处理代理实例，并返回结果
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            Object invoke = method.invoke(proxy, args);
            return invoke;
        }
    }

AOP

AOP：aspect oriented programming（面向切面编程），它是对一类对象或所有对象编程

AOP术语：

• 切面：要实现交叉功能，是系统模块化的一个切面领域，如记录日志
• 连接点：应用程序执行过程中插入切面的地点，可以是方法调用，异常抛出，或者要修改的字段
  • 连接点是一个静态的概念
• 通知： 切面的实际实现，它通知系统的新行为，如日志通知包含了实现日志功能的代码，如向日志文件写日志，通知在连接点插入应用系统中。
• 切入点：定义了通知应该应用在哪些连接点，通知可以应用到AOP框架支持的任何连接点
  • 切入点是动态概念，当通知应用了连接点，连接点就变成了切入点
• 引入：为类添加新方法和属性
• 目标对象：被通知的对象，既可以是你编写的类，也可以是第三方类
• 代理：将通知应用到目标对象后创建后的对象，应用系统的其他部分不用为了支持代理对象而改变
  • spring的两种代理：
    • 若目标对象实现了若干个接口，spring使用JDK的java.lang.reflect.Proxy类代理
    • 若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类
• 织入：将切面应用到目标对象从而创建一个新代理对象的过程，织入发生在目标对象生命周期的多个点上
  • 编译期：切面在目标对象编译时织入，这需要一个特使的编译器
  • 类装载期：切面在目标对象被载入jvm时织入，这需要一个特殊的类加载器
  • 运行期：切面在应用系统运行时切入

声明式事务

事务ACID原则

• 原子性
• 一致性
• 隔离性
  • 多个业务可能操作同一个资源，防止数据破坏
• 持久性
  • 事务一旦提交，无论系统发生什么问题，结果都不会再被影响 ，被持久化的写到存储器中