Spring概括：控制反转与依赖注入

Spring 一：Spring概述

1. 什么是Spring？

   1. 分层设计（持久层mybatis、业务层、控制层）

   2. Java SE/Java EE应用full-stack（全栈式）轻量级 开源的框架

      1. 轻量级：
         • 服务
         • 资源
         • 耦合度

   3. 两大核心

      • IOC ：控制反转（创建对象角度：new；Spring容器）

      • AOP:面向切面编程（在我们不改变源代码的情况下，对业务进行更改）

        • public void  say(){   sout(123);sout(456) }
          

2:Sprig框架的发展史

• 1997：IBM EJB
• 2002年的，EJB
• 2006年：EJB 3.0
• 2017年：spring 5

3：Spring优势

1. 方便解耦，简化开发（IOC）
   • spring容器，它可以对所有对象的创建和销毁提供维护，实现了解耦
     1. 耦合度：对象之间的一种关系。所以要合理的使用耦合度（Spring_IOC）

2.AOP编程的支持

• 了解：面向切面编程

3.声明式事务的支持（数据库）

• 通过配置（xml）来完成事务的支持，不再需要手动的编写代码

4.方便调试，能够使用Juit测试单元

5.方便集成各种优秀的框架

• spring框架，不仅仅生产技术，搬运集成其他的技术

• 依赖

  • 也是一种关系（类和类）；maven体系，整个项目依赖了一些jar。某些类在依赖

4:Spring体系结构

二：IOC :控制反转 -----》解耦

• 解耦的原则

  • 编译时期不依赖，运行时依赖

    •   //第一种方式
              DriverManager.registerDriver(new com.mysql.jdbc.Driver());
              //第二种方式:反射
              Class.forName("com.mysql.jdbc.Driver");
      

• 自定义IOC

  • 实现services层和dao层进行解耦（反射）

  • 步骤分析

    1. 创建Java项目，导入自定义的相关IOC坐标
    2. 编写Dao层和它的实现类
    3. 编写Servces层和实现类
    4. 编写测试代码

三：Spring框架入门案例

• 实现services层和dao层进行解耦
  • 第一步：创建项目，导入依赖（Spring）
  • 第二步：定义xml（解决硬编码）
  • 第三步：容器中取相关对象
  • 第四步:测试代码

四：SpringAPI

• BeanFactory

  • IOC容器的核心接口，它定义了ico的基本功能（解析，ioc）

  • XmlBeanFactory xmlBeanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
            Object u = xmlBeanFactory.getBean("u"); //getbean :创建的实例
    

• ApplicationContext

  • 代表应用上下问对象（spring项目），可以获取spring容器中的对象 ：容器启动的时候

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

• 常用类

  • ClassPathXmlApplicationContext ：当前项目中 推荐使用
    FileSystemXmlApplicationContext：随意的方法
    

• 常用方法

  • getBean(String name):根据id获取ioc容器中的对象
    getBean(String  name,Class class_ ) :根据id和运行时状态
    
    
    

五：Spring配置文件

• bean标签

  • id:Bean在spring容器中的唯一标识
    class：全限定路径名
    * 默认情况调用的式类中的无参构造方法，如果没有无参构造，则会创建失败
    

• bean标签的范围配置

  • 
    prototype:多例
    singleton：单例
    
    

• bean的声明周期配置

  •  
    init:对象创建的时候
    detroy:对象销毁的时候
    

六：bean的实例化

• 无参构造方法

• 工厂方式

package com.Utils;

import com.dao.User02;

public class BeanFactory {

    private static User02 user02;

    static {

        user02 = new User02();

    }

    public static User02  getUser02(){
        return  user02;
    }
    //一步到位
//    public static User02 createBean(){
//        return new User02();
//    }
}

• 静态

package com.Utils;

import com.dao.User02;

public class InstranceFactory {
    private User02 user02;

    public InstranceFactory(){
        user02 = new User02();
    }

    public User02 getUser02(){
        return  user02;
    }

    

}

• 实例

  • 静态工厂：只需要一个bean；实例化工厂至少需要两个bean

• 依赖注入：

  • 它也是Spring框架的IOC的具体体现

    • 在我们编写代码的时候，创建对象的权力交给Spring（IOC），代码中不可能出现没有依赖的情况。

      IOC只能降低他们的依赖关系，但不能消除；Serveices —》Dao

    • 那这种类似业务层和数据持久层的依赖关系。在使用Spring以后，就让Spring来维护了。依赖注入

• 依赖注入分类

  • 构造方法

  • set方法

  • p空间命名法

    • 引入p约束

    • xmlns:p="http://www.springframework.org/schema/p"
      

依赖注入：（基本类型/以用类型）

• 数组、List集合、map集合、自定义

• 环境搭建

  1. 导入依赖

     • 
              
                  org.springframework
                  spring-context
                  5.2.17.RELEASE
              
       
              
                  junit
                  junit
                  4.12
                 
              
           

• 配置文件

• 实验相关类

  • package com;
    
    public class Book {
    }
    -------------------------------
    package com;
    
    import java.util.Arrays;
    import java.util.List;
    import java.util.Map;
    
    public class User {
        private  String name;
        private  int age;
        private List lists;
        private  List  books;
        private  String[]  arr;
        private  Book[] arrbook;
        private Map maps;
        private  Map map_books;
    
        public User() {
        }
    
        public User(String name, int age, List lists, List books, String[] arr, Book[] arrbook, Map maps, Map map_books) {
            this.name = name;
            this.age = age;
            this.lists = lists;
            this.books = books;
            this.arr = arr;
            this.arrbook = arrbook;
            this.maps = maps;
            this.map_books = map_books;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public List getLists() {
            return lists;
        }
    
        public void setLists(List lists) {
            this.lists = lists;
        }
    
        public List getBooks() {
            return books;
        }
    
        public void setBooks(List books) {
            this.books = books;
        }
    
        public String[] getArr() {
            return arr;
        }
    
        public void setArr(String[] arr) {
            this.arr = arr;
        }
    
        public Book[] getArrbook() {
            return arrbook;
        }
    
        public void setArrbook(Book[] arrbook) {
            this.arrbook = arrbook;
        }
    
        public Map getMaps() {
            return maps;
        }
    
        public void setMaps(Map maps) {
            this.maps = maps;
        }
    
        public Map getMap_books() {
            return map_books;
        }
    
        public void setMap_books(Map map_books) {
            this.map_books = map_books;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + ''' +
                    ", age=" + age +
                    ", lists=" + lists +
                    ", books=" + books +
                    ", arr=" + Arrays.toString(arr) +
                    ", arrbook=" + Arrays.toString(arrbook) +
                    ", maps=" + maps +
                    ", map_books=" + map_books +
                    '}';
        }
    }
    
    

数组类型

• 
  
     
          
     
       
            
            
            
            
                 
                      a
                      b
  
                 
            
            
                
                     
                
            
       
  
  

• 测试代码

  •  @org.junit.Test
        public  void method01(){
    
            ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    
            System.out.println(context.getBean("u1",User.class));
        }
    

List集合和数组一样 Map和properties集合

        
            
                aaa
                bbb
            
        
        
            
                
            
        

        
            
        
        
            
        

        
            
                张三
                历史
            
        
    

配置文件模块化（spring）

• 传统的配置文件方式,依赖注入太多，容易乱。我们就可以对配置文件进行拆分，该方式就被称为配置文件模块化（三层架构/功能）

• 实施

  • 主从配置文件

spring整合DBUtils（账户 增删改查 三层架构）

• sql语句

  • CREATE DATAbase spring_db;
    
    USE spring_db;
    CREATE TABLE account(
       id INT PRIMARY KEY AUTO_INCREMENT,
       NAME VARCHAR(20),
       money DOUBLE
    );
    INSERT INTO	account VALUES (NULL,'猪八戒',1000);
    
    

• 依赖坐标

  • 
    
        4.0.0
    
        org.example
        spring_dbuitls
        1.0-SNAPSHOT
    
        
            
                mysql
                mysql-connector-java
                5.1.49
            
            
                commons-dbutils
                commons-dbutils
                1.6
            
            
                com.alibaba
                druid
                1.2.7
            
            
                junit
                junit
                4.12
    
            
            
                org.springframework
                spring-context
                5.2.17.RELEASE
            
        
    
    

• 创建实体类

  • package com.domain;
    
    public class Account {
    
        private  int id;
        private  String name;
        private  double money;
    
        public Account() {
        }
    
        public Account(int id, String name, double money) {
            this.id = id;
            this.name = name;
            this.money = money;
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getMoney() {
            return money;
        }
    
        public void setMoney(double money) {
            this.money = money;
        }
    
        @Override
        public String toString() {
            return "Account{" +
                    "id=" + id +
                    ", name='" + name + ''' +
                    ", money=" + money +
                    '}';
        }
    }
    
    

• 创建DAO

  • 接口

    • package com.Dao;
      
      import com.domain.Account;
      
      import java.util.List;
      
      public interface AccountDao {
      
          //查找所有的账户
          public List findAll();
          //查找单个用户
          public  Account findByid(Integer id);
          //插入账户
          public  void  insert(Account account);
          //修改账户
          public  void  update(Account account);
          //删除账户
          public  void  delete(Integer id);
      
      }
      
      

  • 实现类

    • package com.Dao.imp;
      
      import com.Dao.AccountDao;
      import com.domain.Account;
      
      import java.util.List;
      
      public class AccountDaoImp  implements AccountDao {
          @Override
          public List findAll() {
              return null;
          }
      
          @Override
          public Account findByid(Integer id) {
              return null;
          }
      
          @Override
          public void insert(Account account) {
      
          }
      
          @Override
          public void update(Account account) {
      
          }
      
          @Override
          public void delete(Integer id) {
      
          }
      }
      
      

• Services

  • 接口

    • package com.services;
      
      import com.domain.Account;
      
      import java.util.List;
      
      public interface AccountServices {
      
          //查找所有的账户
          public List findAll();
          //查找单个用户
          public  Account findByid(Integer id);
          //插入账户
          public  void  insert(Account account);
          //修改账户
          public  void  update(Account account);
          //删除账户
          public  void  delete(Integer id);
      }
      
      

  • 实现类

    • package com.services.imp;
      
      import com.Dao.imp.AccountDaoImp;
      import com.domain.Account;
      import com.services.AccountServices;
      
      import java.util.List;
      
      public class AccountServicesImp implements AccountServices {
          //需要Dao层对象
          private AccountDaoImp accountDaoImp;
      
          public AccountServicesImp() {
          }
      
          public AccountServicesImp(AccountDaoImp accountDaoImp) {
              this.accountDaoImp = accountDaoImp;
          }
      
          @Override
          public List findAll() {
              return accountDaoImp.findAll();
          }
      
          @Override
          public Account findByid(Integer id) {
              return accountDaoImp.findByid(id);
          }
      
          @Override
          public void insert(Account account) {
              accountDaoImp.insert(account);
          }
      
          @Override
          public void update(Account account) {
              accountDaoImp.update(account);
          }
      
          @Override
          public void delete(Integer id) {
              accountDaoImp.delete(id);
          }
      }
      
      

• 实现查询所有用户

  • dao层查询所有方法

    • package com.services.imp;
      
      import com.Dao.imp.AccountDaoImp;
      import com.domain.Account;
      import com.services.AccountServices;
      
      import java.util.List;
      
      public class AccountServicesImp implements AccountServices {
          //需要Dao层对象
          private AccountDaoImp accountDaoImp;
      
          public AccountServicesImp() {
          }
      
          public AccountServicesImp(AccountDaoImp accountDaoImp) {
              this.accountDaoImp = accountDaoImp;
          }
      
          @Override
          public List findAll() {
              return accountDaoImp.findAll();
          }
      
          @Override
          public Account findByid(Integer id) {
              return accountDaoImp.findByid(id);
          }
      
          @Override
          public void insert(Account account) {
              accountDaoImp.insert(account);
          }
      
          @Override
          public void update(Account account) {
              accountDaoImp.update(account);
          }
      
          @Override
          public void delete(Integer id) {
              accountDaoImp.delete(id);
          }
      }
      
      

  • ioc依赖注入

  • 测试数据

    •  //查询所有操作
          @Test
          public  void method(){
      
              //spring+dbutils+druid整合
              ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
              AccountServicesImp imp = context.getBean("accountServicesImp", AccountServicesImp.class);
              List all = imp.findAll();
              System.out.println(all);
          }
      

Spring引入jdbc.properties文件

• 引入context命名空间和约束路径

  • 命名空间s
    xmlns:context="http://www.springframework.org/schema/context"
    约束
     http://www.springframework.org/schema/context
     http://www.springframework.org/schema/context/spring-context.xsd
    

• xml文件配置

  • 注意事项

    • properties文件键和注入的成员变量名称区分开（jdbc.）

注解

• 开启注解扫描