Spring的介绍与入门

Spring介绍与入门

    1.什么是Spring?
        Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。
        简单来说，Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。
        一站式:Spring提供了三层解决方案.
        
    2.Spring的优点：
        1.方便解耦，简化开发
​        通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，
        避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、
        属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
        2.AOP编程的支持
        通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。
        3.声明式事务的支持
        在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。
        4.方便集成各种优秀框架 
    3.Spring的两大核心:IOC和AOP
    4.SpringIOC的入门：
        4.1 创建工程ioc，添加依赖；
            <?xml version="1.0" encoding="UTF-8"?>
            <project xmlns="http://maven.apache.org/POM/4.0.0"
                     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
                <modelVersion>4.0.0</modelVersion>

                <groupId>com.it</groupId>
                <artifactId>ioc</artifactId>
                <version>1.0-SNAPSHOT</version>

                <properties>
                    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
                    <maven.compiler.source>1.8</maven.compiler.source>
                    <maven.compiler.target>1.8</maven.compiler.target>
                </properties>

                <dependencies>
                    <dependency>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-context</artifactId>
                        <version>5.0.2.RELEASE</version>
                    </dependency>
                </dependencies>
            </project>
        4.2 准备接口和实现类：
            注：这里只是模拟，所以简单写Service和Dao
            service接口和实现类：
            public interface AccountService {
                /**
                 * 保存账户
                 */
                void save();
            }
            public class AccountServiceImpl implements AccountService {
                /**
                 * 保存账户
                 */
                @Override
                public void save() {
                    System.out.println("AccountServiceImpl---saveAccount()");
                    AccountDao accountDao = new AccountDaoImpl();//TODO 耦合待解决
                    accountDao.save();
                }
            }
            dao接口和实现类：
            public interface AccountDao {
                /**
                 * 保存账户
                 */
                void save();
            }
            public class AccountDaoImpl implements AccountDao {
                /**
                 * 保存账户
                 */
                @Override
                public void save() {
                    System.out.println("AccountDaoImpl---saveAccount()");

                }
            }
        4.3 spring配置文件：applicationContext.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"
                   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
                <!--id：作为唯一标识，不要重复，一般写接口或者类名，首字母小写
                    class属性：写类的全路径名，注意如果是接口，要写接口的实现类的全路径名-->
                <bean id="accountDao" class="com.it.dao.impl.AccountDaoImpl"></bean>
            </beans>
            
        4.4 使用时从spring容器中获取对象：
            public class IocTest {
                @Test
                public void fun(){
                    //1.获得工厂对象
                    ApplicationContext applicationContext= new ClassPathXmlApplicationContext("applicationContext.xml");
                    //从工厂获取对象
                    AccountDao accountDao = (AccountDao) applicationContext.getBean("accountDao");
                    //调用方法
                    accountDao.save();
                }
            }
            
    基于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"
               xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

            <!--
                bean标签: 注册bean, 把对象交给Spring管理
                1.【掌握】属性:
                    id/name属性: 随便写,作为bean的唯一标识,不要重复(建议写接口的名字,首字母小写)
                    class属性:  类的全限定名
                    scope属性:  singleton 单例,  不管获得多少次 都是同一个, 创建出来存到Spring容器里面  【默认】
                                prototype 多例,  每获得一次 就创建一个新的对象,创建出来不会存到Spring容器里面

                                request 把创建的对象存到request域,针对web项目【了解】
                                session 把创建的对象存到session域,针对web项目【了解】
                                我们一般也是单例的, 特殊情况才是设置为prototype多例 eg:struts2里面的action
               2. 【了解】的属性
                    init-method属性: 指定初始化方法,写方法名
                    destroy-method属性: 指定销毁的方法, 象征着当前对象从Spring容器里面移除了 写方法名
            -->
            <bean id="accountService" class="com.it.service.impl.AccountServiceImpl" scope="prototype"
                init-method="initMethod" destroy-method="destoryMethod"
            ></bean>

        </beans>
        
    id/name属性
  ​    用于标识bean ， 其实id 和 name都必须具备唯一标识 ，两种用哪一种都可以。但是一定要唯一、 一般开发中使用id来声明. 
    class属性: 用来配置要实现化类的全限定名
    scope属性: 用来描述bean的作用范围
  ​    singleton: 默认值，单例模式。spring创建bean对象时会以单例方式创建。(默认)
  ​    prototype: 多例模式。spring创建bean对象时会以多例模式创建。    
  ​    request: 针对Web应用。spring创建对象时，会将此对象存储到request作用域。    
  ​    session: 针对Web应用。spring创建对象时，会将此对象存储到session作用域。    
    init-method属性：spring为bean初始化提供的回调方法
    destroy-method属性：spring为bean销毁时提供的回调方法. 销毁方法针对的都是单例bean ， 如果想销毁bean , 可以关闭工厂

    bean的作用范围和生命周期 
    单例对象： scope="singleton"
      ​    一个应用只有一个对象的实例。它的作用范围就是整个引用。
      ​    生命周期：
      ​        对象出生：当应用加载，创建容器时，对象就被创建了。
      ​        对象活着：只要容器在，对象一直活着。
      ​        对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

    多例对象： scope="prototype"
  ​    每次访问对象时，都会重新创建对象实例，多例的bean不会存到Spring容器里面
  ​    生命周期：
  ​        对象出生：当使用对象时，创建新的对象实例。
  ​        对象活着：只要对象在使用中，就一直活着。
  ​        对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了.

    spring中使用的主要工厂对象：
        - ClassPathXmlApplicationContext：它是从类的根路径下加载配置文件 
        - FileSystemXmlApplicationContext：它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
        - AnnotationConfigApplicationContext:当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。
        
    BeanFactory 和 ApplicationContext 的区别：
        ApplicationContext加载方式是框架启动时就开始创建所有单例的bean,存到了容器里面
​        BeanFactory加载方式是用到bean时再加载(目前已经被废弃)