Spring01-黑马-笔记

Spring01

Spring Framework

1、Spring系统架构

系统架构

(1)核心层

• Core Container:核心容器，这个模块是Spring最核心的模块，其他的都需要依赖该模块

(2)AOP层

• AOP:面向切面编程，它依赖核心层容器，目的是在不改变原有代码的前提下对其进行功能增强
• Aspects:AOP是思想,Aspects是对AOP思想的具体实现

(3)数据层

• Data Access:数据访问，Spring全家桶中有对数据访问的具体实现技术 Data
• Integration:数据集成，Spring支持整合其他的数据层解决方案，比如Mybatis
• Transactions:事务，Spring中事务管理是Spring AOP的一个具体实现，也是后期学习的 重点内容

(4)Web层

• 这一层的内容将在SpringMVC框架具体学习

(5)Test层

• Spring主要整合了Junit来完成单元测试和集成测试

Spring核心概念

IOC（Inversion of Control）控制反转
使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转。
DI（Dependency Injection）依赖注入
被创建或被管理的对象在IOC容器中统称为Bean

2、入门案例

Ioc入门案例

(1)Spring是使用容器来管理bean对象的，那么管什么?
主要管理项目中所使用到的类对象，比如(Service和Dao)
(2)如何将被管理的对象告知IOC容器?
使用配置文件
(3)被管理的对象交给IOC容器，要想从容器中获取对象，就先得思考如何获取到IOC容器?
Spring框架提供相应的接口
(4)IOC容器得到后，如何从容器中获取bean?
调用Spring框架提供对应接口中的方法
(5)使用Spring导入哪些坐标?
用别人的东西，就需要在pom.xml添加对应的依赖

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.20</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.1</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

<?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">

<!--    1.导入spring的坐标-->
<!--    2、配置bean-->

    <!--bean标签标示配置bean
        id属性标示给bean起名字
        class属性表示给bean定义类型
        -->
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
    <bean id="bookService" class="com.itheima.Service.impl.BookServiceImpl"/>


</beans>

package com.itheima;

import com.itheima.Service.BookService;
import com.itheima.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App2 {
    public static void main(String[] args) {
        //3获取ioc容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //4获取bean
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();

        //4获取service
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();
    }
}

DI入门案例

(1)要想实现依赖注入，必须要基于IOC管理Bean
DI的入门案例要依赖于前面IOC的入门案例
(2)Service中使用new形式创建的Dao对象是否保留?
需要删除掉，最终要使用IOC容器中的bean对象
(3)Service中需要的Dao对象如何进入到Service中?
在Service中提供方法，让Spring的IOC容器可以通过该方法传入bean对象
(4)Service与Dao间的关系如何描述?
使用配置文件

package com.itheima.Service.impl;

import com.itheima.Service.BookService;
import com.itheima.dao.BookDao;

public class BookServiceImpl implements BookService {
    //5.删除业务层中使用new的方式创建的dao对象
    //private BookDao bookDao = new BookDaoImpl();
    private BookDao bookDao;
    @Override
    public void save() {
        System.out.println("book service save...");
        bookDao.save();
    }

    //6.提供对应的set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

    <bean id="bookService" class="com.itheima.Service.impl.BookServiceImpl">
<!--        7.配置service与dao的关系-->
        <!--property标签表示配置当前bean的属性
        name属性表示配置哪一个具体的属性
        ref属性表示参照哪一个bean
        -->
        <property name="bookDao" ref="bookDao"/>
    </bean>

3.bean配置

bean的配置别名

<bean id="bookDao" name="dao bookDao2" class="com.itheima.dao.impl.BookDaoImpl"/>
    <bean id="bookService" name="bookService2 service bookService3" class="com.itheima.Service.impl.BookServiceImpl">
<!--        7.配置service与dao的关系-->
        <!--property标签表示配置当前bean的属性
        name属性表示配置哪一个具体的属性
        ref属性表示参照哪一个bean
        -->
        <property name="bookDao" ref="bookDao"/>
    </bean>

bean作用范围scope配置

 <bean id="bookDao" name="dao bookDao2" class="com.itheima.dao.impl.BookDaoImpl" scope="prototype"/>

import com.itheima.Service.BookService;
import com.itheima.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App2_forScope {
    public static void main(String[] args) {
        //3获取ioc容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //4获取bean
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        BookDao bookDao1 = (BookDao) ctx.getBean("bookDao");
        System.out.println(bookDao);
        System.out.println(bookDao1);
    }
}

• singleton 默认为单例
• prototype 为非单例

哪些bean对象适合交给容器进行管理?

• 表现层对象
• 业务层对象
• 数据层对象
• 工具对象

哪些bean对象不适合交给容器进行管理?

• 封装实例的域对象，因为会引发线程安全问题，所以不适合。

实例化bean

三种方式

方式一 ：构造方法（常用）

package com.itheima.dao.impl;
import com.itheima.dao.BookDao;

public class BookDaoImpl implements BookDao {

    public BookDaoImpl() {
        System.out.println("book dao constructor is running...");
    }

    @Override
    public void save() {
        System.out.println("book dao save...");
    }
}

方式二 ：静态工厂

package com.itheima.factory;

import com.itheima.dao.OrderDao;
import com.itheima.dao.impl.OrderDaoImpl;

public class OrderDaoFactory {
    public static OrderDao getOrderDao(){
        return new OrderDaoImpl();
    }
}

<!--方式二-->
<bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>

import com.itheima.dao.OrderDao;
import com.itheima.factory.OrderDaoFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppForInstanceOrder {
    public static void main(String[] args) {
        //通过工厂创建对象
//        OrderDao orderDao = OrderDaoFactory.getOrderDao();
//        orderDao.save();

        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");

        orderDao.save();
    }
}

方式三 ：实例工厂

package com.itheima.factory;

import com.itheima.dao.UserDao;
import com.itheima.dao.impl.UserDaoImpl;

public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

  <!--方式三-->
    <bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>
    <bean id="userdao"  factory-method="getUserDao" factory-bean="userFactory"/>

import com.itheima.dao.UserDao;
import com.itheima.factory.UserDaoFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppForInstanceUser {
    public static void main(String[] args) {
//        //创建实例工厂对象
//        UserDaoFactory userDaoFactory = new UserDaoFactory();
//        //通过实例工厂对象创建对象
//        UserDao userDao = userDaoFactory.getUserDao();
//        userDao.save();

        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserDao userDao = (UserDao) ctx.getBean("userDao");

        userDao.save();
    }
}

方式三改良版 FactoryBean（实用）

package com.itheima.factory;

import com.itheima.dao.UserDao;
import com.itheima.dao.impl.UserDaoImpl;
import org.springframework.beans.factory.FactoryBean;

public class UserDaoFactoryBean implements FactoryBean<UserDao> {
   //代替原始实例工厂中创建对象的方法
    @Override
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }


    @Override
    public Class<?> getObjectType() {
        return UserDao.class;
    }

    @Override
    public boolean isSingleton() {
        //return false;//非单例
        return true;//单例
    }
}

<!-- 方式三改良版 -->
    <bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>

bean生命周期

设置生命周期

package com.itheima.dao.impl;

import com.itheima.dao.BookDao;

public class BookDaoImpl implements BookDao {
    @Override
    public void save() {
        System.out.println("book dao save...");
    }

    //bean初始化对应的操作
    public void init(){
        System.out.println("init ...");
    }

    //bean销毁前对应的操作
    public void destory(){
        System.out.println("destory ...");
    }
}

 <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>
   

import com.itheima.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppForLifeCycle {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        ctx.registerShutdownHook();//位置放在哪里都可以

        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        bookDao.save();
        //ctx.close();//暴力方式
    }
}

使用接口控制

package com.itheima.Service.impl;


import com.itheima.Service.BookService;
import com.itheima.dao.BookDao;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
    private BookDao bookDao;
    @Override
    public void save() {
        System.out.println("book service save...");
        bookDao.save();
    }

    //6.提供对应的set方法
    public void setBookDao(BookDao bookDao) {
        System.out.println("set ...");
        this.bookDao = bookDao;
    }

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

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

4、DI依赖注入

Spring为我们提供了两种注入方式，分别是:
setter注入

• 简单类型
• 引用类型

构造器注入

• 简单类型
• 引用类型

setter注入

引用类型

package com.itheima.Service.impl;

import com.itheima.Service.BookService;
import com.itheima.dao.BookDao;
import com.itheima.dao.UserDao;

public class BookServiceImpl implements BookService {

    private BookDao bookDao;
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void save() {
        System.out.println("book service save...");
        bookDao.save();
        userDao.save();
    }

    //6.提供对应的set方法
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

   <bean id="bookDao"  class="com.itheima.dao.impl.BookDaoImpl" />

    <bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>

    <bean id="bookService"  class="com.itheima.Service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDao"/>
        <property name="userDao" ref="userDao"/>
    </bean>

import com.itheima.Service.BookService;
import com.itheima.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppForDISet {
    public static void main(String[] args) {
        //3获取ioc容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //4获取bean
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();

    }
}

简单类型

<bean id="bookDao"  class="com.itheima.dao.impl.BookDaoImpl" >
        <property name="connectionNum" value="10"/>
        <property name="databaseName" value="mysql"/>
    </bean>

构造器注入

引用类型

package com.itheima.Service.impl;

import com.itheima.Service.BookService;
import com.itheima.dao.BookDao;
import com.itheima.dao.UserDao;

public class BookServiceImpl implements BookService {

    private BookDao bookDao;
    private UserDao userDao;

    public BookServiceImpl(BookDao bookDao, UserDao userDao) {
        this.bookDao = bookDao;
        this.userDao = userDao;
    }

    public BookServiceImpl(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    @Override
    public void save() {
        System.out.println("book service save...");
        bookDao.save();
        userDao.save();
    }
}

    <bean id="bookDao"  class="com.itheima.dao.impl.BookDaoImpl" />
	<bean id="userDao"  class="com.itheima.dao.impl.UserDaoImpl" />
    <bean id="bookService"  class="com.itheima.Service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
    </bean>

简单类型

package com.itheima.dao.impl;

import com.itheima.dao.BookDao;

public class BookDaoImpl implements BookDao {

    private int connectionNum;
    private String databaseName;

    public BookDaoImpl(int connectionNum, String databaseName) {
        this.connectionNum = connectionNum;
        this.databaseName = databaseName;
    }

    @Override
    public void save() {
        System.out.println("book dao save..."+connectionNum+","+databaseName);
    }
}

	<bean id="bookDao"  class="com.itheima.dao.impl.BookDaoImpl" >
        <constructor-arg name="connectionNum" value="10"/>
        <constructor-arg name="databaseName" value="mysql"/>
    </bean>

   <!--解决形参名称问题
    <bean id="bookDao"  class="com.itheima.dao.impl.BookDaoImpl" >
        <constructor-arg type="java.lang.Integer" value="10"/>
        <constructor-arg type="java.lang.String" value="mysql"/>
    </bean>
    <bean id="userDao"  class="com.itheima.dao.impl.UserDaoImpl" />

    <bean id="bookService"  class="com.itheima.Service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>
-->
    <!--解决参数类型重复问题
    <bean id="bookDao"  class="com.itheima.dao.impl.BookDaoImpl" >
        <constructor-arg index="0" value="10"/>
        <constructor-arg index="1" value="mysql"/>
    </bean>
    <bean id="userDao"  class="com.itheima.dao.impl.UserDaoImpl" />

    <bean id="bookService"  class="com.itheima.Service.impl.BookServiceImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
        <constructor-arg name="userDao" ref="userDao"/>
    </bean>
-->

自动配置

按类型（用这个）

要求类型唯一

  <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" />
    <bean id="bookService" name="bookService2 service bookService3" class="com.itheima.Service.impl.BookServiceImpl" autowire="byType"/>

按名称

<bean id="bookService" name="bookService2 service bookService3" class="com.itheima.Service.impl.BookServiceImpl" autowire="byName"/>

1. 自动装配用于引用类型依赖注入，不能对简单类型进行操作
2. 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
3. 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推
   荐使用
4. 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效

集合注入

package com.itheima.dao.impl;

import com.itheima.dao.BookDao;

import java.util.*;

public class BookDaoImpl implements BookDao {

    private int[] array;
    private List<String> list;
    private Set<String> set;
    private Map<String,String> map;
    private Properties properties;

    public void setArray(int[] array) {
        this.array = array;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    @Override
    public void save() {
        System.out.println("book dao save...");
        System.out.println("遍历数组"+ Arrays.toString(array));
        System.out.println("遍历List"+ list);
        System.out.println("遍历set"+ set);
        System.out.println("遍历map"+ map);
        System.out.println("遍历Properties"+ properties);
    }
}

<?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="bookDao" class="com.itheima.dao.impl.BookDaoImpl" >
        <property name="array" >
            <array>
                <value>100</value>
                <value>300</value>
                <value>200</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>wyy</value>
                <value>ccc</value>
                <value>aaa</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>wyy</value>
                <value>ccc</value>
                <value>aaa</value>
                <value>aaa</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="country" value="china"/>
                <entry key="province" value="henan"/>
                <entry key="city" value="kaifeng"/>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="country">china</prop>
                <prop key="province">henan</prop>
                <prop key="city">kaifeng</prop>
            </props>
        </property>
    </bean>

</beans>