spring

spring(spring framework系统架构)

**tips：**spring报错从后面开始查看；

1.core container(核心容器)

1.IOC/DI

<!--第一步，在pom.xml中导入spring5.2.10版本的核心依赖-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>
<!--第二步，创建applicationContext.xml文件，配一个context的xmlns用来加载配置文件，bean管理-->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation=
               "http://www.springframework.org/schema/beans
                http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/context
                http://www.springframework.org/schema/context/spring-context.xsd
                "
        >
<!--配置bean，不要配接口，配类
	scope属性：是配置对象是否为单例,
	prototype为非单例；
	singleton为单例，默认单例；
	name是给id起别名，用空格，逗号，分号隔开；
-->
    <bean id="bookDao" name="bookDao2 bookDao3" class="org.example.dao.BookDao" scope="singleton">
    </bean>
    
<!--    依赖注入 提供setter方法；或者提供有参构造方法（后面有写）
		引用类型：其中name的值是类中的对象名，ref是关联bean对象的id；
		基本类型：name value；
-->
    <bean id="bookImpl" class="org.example.impl.BookImpl">
        <property name="bookDao" ref="bookDao"></property>
    </bean>
    
 <!--    依赖注入自动装配：（引用类型）
		 byName（id名）,
		 byType（配置的bean唯一）
-->
    <bean id="bookImpl" class="org.example.impl.BookImpl" autowire="byType"/>
    
<!--    集合注入格式-->
    <bean id="listDao" class="org.example.dao.BookDao">
        <property name="array">
            <array><value>haod</value></array>
        </property>
        
        <property name="list">
            <list>
                <!--list集合是基本类型或者String-->
                <value>haod</value>
                <!--list集合是引用类型-->
                <ref bean="此地方填写bean的id"/>
            </list>
        </property>
        
        <property name="set">
            <set>
                <!--与list相似-->
                <value>haod</value>
            </set>
        </property>
        
        <property name="map">
            <map>
                <entry key="" value=""/>
            </map>
        </property>
        
        <property name="properties">
            <props>
                <prop key="">value值</prop>
            </props>
        </property>
    </bean>
    
<!--    加载properties配置文件,
		location 可以写成 classpath*:*.properties 加载所有properties文件
		system-properties-mode="NEVER"是不加载系统属性-->
    <context:property-placeholder location="db.properties" system-properties-mode="NEVER"/>
</beans>

//第三步，获取容器对象
//        两种获得容器方法，可加载多个配置文件("applicationContext.xml","...xml");第一个是相对路径，第二个是绝对路径；
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//        ApplicationContext ctx = new FileSystemXmlApplicationContext("D:\\idea\\workspace\\ssm\\spring\\src\\main\\resources\\applicationContext.xml");
//第四步，获取bean对象，然后调用方法；
//        三种获取bean对象方法 1.根据id名获取并强转 2.根据类型获取 3.根据id和反射获取
//        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
//        BookDao bookDao = ctx.getBean(BookDao.class);
        BookDao bookDao = ctx.getBean("bookDao", BookDao.class);

封装实体的域对象不适合交给容器进行管理（有状态的）

2.bean实例化

1.无参构造方法（私有也可以）默认执行

<bean id="bookDao" name="bookDao2 bookDao3" class="org.example.dao.BookDao" scope="prototype"/>

2.静态工厂（static方法）

public class SFactory {
    public static BookDao getBookDao(){
        return new BookDao();
    }
}

• 配置

<!--    静态工厂实例化bean对象-->
    <bean id="sfactory" class="org.example.factory.SFactory" factory-method="getBookDao"/>

3.实例工厂

public class InstanceFactory {
    public BookDao getBookDao(){
        return new BookDao();
    }
}

• 配置

<!--    实例工厂实例化bean
		先造工厂对象bean
-->
    <bean id="ifactory" class="org.example.factory.InstanceFactory"/>
    <bean id="bookDaoFactory" factory-bean="ifactory" factory-method="getBookDao"/>

4.实例工厂的升级，factoryBean(重要)

实现FactoryBean<>接口；

public class DaoFactoryBean implements FactoryBean<BookDao> {
//    代替原始实例工厂创建对象的方法，统一方法名
    @Override
    public BookDao getObject() throws Exception {
        return new BookDao();
    }

//    告诉对象是什么类型
    @Override
    public Class<?> getObjectType() {
        return BookDao.class;
    }
}

• 配置（配置简单）

<!--    factoryBean实例化bean-->
    <bean id="fbBookDao" class="org.example.factory.DaoFactoryBean"/>

3.bean生命周期

初始化容器{创建对象（内存分配）–>执行构造方法–>属性注入(set操作)–>执行bean初始化方法–}>

使用bean{执行业务操作}–>销毁容器{执行bean雄销毁方法}

1.自己在类中写(配置生命周期)

public class BookDao {
    public int getAll(){
        return 2;
    }
    public void init(){
        System.out.println("init.....");
    }
    public void destroy(){
        System.out.println("destroy");
    }
}

• 配置

<bean id="bookDao" name="bookDao2 bookDao3" class="org.example.dao.BookDao" scope="prototype" init-method="init" destroy-method="destroy">
</bean>

销毁bean：

//        销毁bean：ClassPathXmlApplicationContext可以调用销毁方法
//                 1.close（）暴力关闭且位置只能放最后
//                 2.registerShutdownHook()位置放哪都行，(设置关闭勾子)
//        ctx.close();
        ctx.registerShutdownHook();

2.按Spring要求写：

实现两个接口：InitializingBean, DisposableBean

public class BookImpl implements BookService, InitializingBean, DisposableBean {
    private BookDao bookDao;

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
    @Override
    public int allBook() {
        return bookDao.getAll();
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("destroy");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("init");
    }
}

4.依赖注入方式

1.setter注入

直接写setter方法，正常配置bean

2.有参构造器注入

不写setter方法，写有参构造，把需要注入的都写进有参构造中的参数；

• 配置

<!--    依赖注入 其中name的值是类中构造器参数名，
                index是参数位置索引
                ref是bean对象的id （ref可换成value注入基本类型）
-->
    <bean id="bookImpl" class="org.example.impl.BookImpl">
        <!-- 标准书写 name的耦合性较高-->
<!--        <constructor-arg name="bookDao" ref="bookDao"></constructor-arg>-->
        <constructor-arg index="0" ref="bookDao"></constructor-arg>
    </bean>

5.第三方bean管理

1.第一步导入pom.xml依赖坐标；

2.第二步，配置bean

eg:配置druid数据源

<!--导入druid依赖坐标-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.2.8</version>
    </dependency>
<!--    加载第三方资源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driver" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc://mysql:localhost:3306/spring?useSSL=false"></property>
        <property name="username" value="root"></property>
        <property name="password" value="123456"></property>
    </bean>