初识Spring学习笔记---IOC

小咪咪 2023-01-03 14:11 177阅读 0赞

## 一、Spring概述 ##

### 1.Spring是什么 ###

Spring是分层的Java SE/EE应用full-stack轻量级开源框架，以IOC(Inversion Of Control：控制反转)和AOP(Aspect Oriented Programming：面向切面编程)为内核，提供了展现层Spring MVC和持久层Spring JDBC以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE企业应用开源框架

2.Spring体系结构

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA3MDQ3Mw_size_16_color_FFFFFF_t_70][]

## 二、程序的耦合及解耦 ##

1.耦合连接JDBC

public static void main(String[] args) throws SQLException {
            //1.注册驱动
            DriverManager.registerDriver(new com.mysql.jdbc.Driver());
           
    
            //2.获取连接
            Connection conn=DriverManager.getConnection("jdbc:mysql://localhost:3306/spring_study","root","wh456159");
    
            //3.获取操作数据库的预处理
            PreparedStatement pstm=conn.prepareStatement("select  * from account");
    
            //4.执行SQL,得到结果集
            ResultSet rs=pstm.executeQuery();
    
            //5.遍历结果集
            while (rs.next()){
                System.out.println(rs.getString("name") );
            }
    
            //6.释放资源
            rs.close();
            pstm.close();
            conn.close();
    
        }

\* 程序的耦合  
\*       耦合：程序间的依赖关系  
\*          包括：  
\*              类之间的依赖  
\*              方法间的依赖

###    2.解耦 ###

\*       解耦：降低程序间的依赖关系  
\*       实际开发中：做到编译期不依赖，运行时才依赖。  
\*       解耦的思路：  
**\*           第一步：使用反射来创建对象，而避免使用new关键字**

//1.注册驱动
           // DriverManager.registerDriver(new com.mysql.jdbc.Driver());
            Class.forName("com.mysql.jdbc.Driver");

**注：**反射中，欲获取一个类或者调用某个类的方法，首先要获取到该类的 Class 对象。

获取 Class 对象三种方法：①使用 Class.forName 静态方法  ②使用 .class 方法  ③使用类对象的 getClass() 方法

**但上述使用Class.forName("com.mysql.jdbc.Driver")  如果之后更换数据库例如使用oracle时，代码就不成立。**

**\*           第二步：通过读取配置文件来获取要创建的对象全限定类名**

*  配置文件可以是xml也可以是properties

此处使用properties:（在resouces目录下创建.properties,然后分别指定业务层acountService和持久层acountDao的实现类的全限定类名）

accountService=com.wuhao.service.implement.AccountServiceImpl
    accountDao=com.wuhao.dao.implement.AccountDaoImpl

/**
     * 一个创建Bean对象的工厂
     *
     * Bean:在计算机英语中，有可重用组件的含义
     * JavaBean:  用Java语言编写的可重用组件
     *      javabean > 实体类
     *
     *  它就是创建我们的service和dao对象的
     *
     *  第一个：需要一个配置文件来配置我们的service和dao
     *          配置的内容：唯一标识=全限定类名（key=value）
     *  第二个：通过读取配置文件中配置的内容，反射创建对象
     *
     *  配置文件可以是xml也可以是properties
     */

public class BeanFactory {
    
        //定义一个Properties对象
        private static Properties properties;
    
        //定义一个Map,用于存放我们要创建的对象。 称之为容器
        private static Map<String,Object> beans;
    
        //使用静态代码块为Properties对象赋值
        static {
    
            try {
                //实例化对象
                properties=new Properties();
    
                //获取properties文件的流对象
    //        InputStream inputStream=new FileInputStream("");     使用这种方法增加了耦合性
                InputStream inputStream=BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");  //使用类加载器
                properties.load(inputStream);
    
                //实例化容器
                beans=new HashMap<String, Object>();
                //取出配置文件中所有的key
                Enumeration keys=properties.keys();
                //遍历枚举
                while (keys.hasMoreElements()) {
                    //取出每个key
                    String key=keys.nextElement().toString();
                    //根据key获取value
                    String beanPath=properties.getProperty(key);
                    //反射创建对象
                    Object value=Class.forName(beanPath).newInstance();
                    //把Key和Value存入容器中
                    beans.put(key, value);
    
                }
            } catch (IOException e) {
                throw new ExceptionInInitializerError("初始化properties失败！");
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    
    
        /**
         * 根据bean的名称获取对象
         * @param beanName
         * @return
         */
        public static Object getBean(String beanName){      //实现了单例模式
            return beans.get(beanName);
        }
    
        /**
         * 根据Bean的名称获取bean对象
         * @param beanName
         * @return
         */
    /*    public static Object getBean(String beanName){    //多例模式
            Object bean=null;
    
            try {
                String beanPath=properties.getProperty(beanName);
                bean=Class.forName(beanPath).newInstance();  //实例化   每次都会调用默认构造函数创建对象   若长时间不用会被java垃圾回收机制销毁
    
            } catch (Exception e) {
                e.printStackTrace();
             }
            return bean;
        }*/
    }

## 三、IOC概念和Spring中的IOC ##

### 1.IOC ###

通过代码解释IOC(Inversion Of Control：控制反转):

private IAccountDao accountDao=new AccountDaoImpl();

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA3MDQ3Mw_size_16_color_FFFFFF_t_70 1][]

用关键字new创建对象，就像从APP寻找资源一样，会存在必然联系。这时候对于应用的独立变得很难

private IAccountDao accountDao= (IAccountDao) BeanFactory.getBean("accountDao");

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA3MDQ3Mw_size_16_color_FFFFFF_t_70 2][]

这种方式下，APP已经断开了与资源的联系。APP找工厂索要资源，由工厂负责与资源取的联系，并把想要的资源转到APP中。

这种被动接收的方式获取对象的思想就是控制反转，它是spring框架的核心之一。

**控制反转**（Inversion of Control）把创建对象的权利交给框架，是框架的重要特征，并非面向对象编程的专用术语。它包括依赖注入（Dependency Injection,DI）和依赖查找（Dependency Lookup）。

**IOC作用：**消减计算机程序的耦合（解除我们代码中的依赖关系）。

### 2.Spring中的IOC ###

* 获取spring的IOC核心容器，并根据id获取对象

//1.获取核心容器对象
            ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");//bean.xml为配置文件
    
            //2.根据id获取Bean对象   两种方式（强转或指定接口）
            IAccountService as=(IAccountService)ac.getBean("accountService"); 
            IAccountDao adao=ac.getBean("accountDao",IAccountDao.class);

\*在Spring中的配置文件

/**
     * 账户的业务层实现类
     */
    public class AccountServiceImpl implements IAccountService {
    
    
        /**
         * 解耦后
         */
    
        public AccountServiceImpl(){
            System.out.println("对象已创建");
        }  //默认构造函数
    
        @Override
        public void saveAccount() {
    
            System.out.println("service中的saveAccount方法执行了。。。");
        }
    
    }

/**
     * 模拟一个工厂类（该类可能是存在于jar包中，我们无法通过修改源码的方式来提供默认构造函数）
     */
    public class InstanceFactory {
    
        public IAccountService getAccountService() {
            System.out.println("InstanceFactory被调用");
            return new AccountServiceImpl();
        }
    
    }

public class StaticFactory {
    
    
        public static IAccountService getAccountService() {
            System.out.println("StaticFactory被调用");
            return new AccountServiceImpl();
        }
    
    }

public static void main(String[] args) {
    
            //1.获取核心容器对象
            ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
    
    
            //2.根据id获取Bean对象
            IAccountService as1=(IAccountService)ac.getBean("accountService");
            IAccountService as2=(IAccountService)ac.getBean("accountService");
            System.out.println(as1==as2);
            
        }

结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA3MDQ3Mw_size_16_color_FFFFFF_t_70 3][]

改变配置文件，加入scope属性：

结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA3MDQ3Mw_size_16_color_FFFFFF_t_70 4][]

<!--bean对象的生命周期
           单例对象
               出生：当容器创建时对象出生
               活着：只要容器还在，对象一直活着
               死亡：容器摧毁，对象消亡
               总结：单例对象的生命周期和容器相同

public static void main(String[] args) {
    
            //1.获取核心容器对象
    //        ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
            ClassPathXmlApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
    
            //2.根据id获取Bean对象
            IAccountService as=(IAccountService)ac.getBean("accountService");
            as.saveAccount();
    
            //手动关闭容器
            ac.close();
    
        }

结果：

![20210109131739596.png][]

多例对象
        出生：当使用对象时spring框架为我们创建
        活着：对象在使用过程中一直活着。
        死亡：当对象长时间不用，且没有别的对象引用是，由Java的垃圾回收器回收

结果：

![20210109132122793.png][]

## 四、依赖注入（Dependency Injection） ##

/**
     * 账户的业务层实现类
     */
    public class AccountServiceImpl implements IAccountService {
    
    
        //如果是经常变化的数据，并不适用于注入的方式
        private String name;
        private Integer age;
        private Date birthday;
    
        public AccountServiceImpl(String name,Integer age,Date birthday){
            this.name = name;
            this.age = age;
            this.birthday=birthday;
        }
    
        @Override
        public void saveAccount() {
    
            System.out.println("service中的saveAccount方法执行了。。。");
            System.out.println(name+age+birthday);
        }
        
    
    }

public class AccountServiceImpl02 implements IAccountService {
    
        //如果是经常变化的数据，并不适用于注入的方式
        private String name;
        private Integer age;
        private Date birthday;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setUserAge(Integer age) {
            this.age = age;
        }
    
        public Date getBirthday() {
            return birthday;
        }
    
        public void setBirthday(Date birthday) {
            this.birthday = birthday;
        }
    
        @Override
        public void saveAccount() {
    
            System.out.println("service中的saveAccount方法执行了。。。");
            System.out.println(name+age+birthday);
        }
    }

注：userAge，这是因为name：用于指定注入时所调用的set方法名称，在AccountServiceImp02实现类里面使用setUserAge()方法设置age的值。

public class AccountServiceImpl03 implements IAccountService {
    
        private String[] myStrs;
        private List<String>  myList;
        private Set<String> mySet;
        private Map<String,String> myMap;
        private Properties myProperties;
    
        @Override
        public void saveAccount() {
            System.out.println(Arrays.toString(myStrs));
            System.out.println(myList);
            System.out.println(mySet);
            System.out.println(myMap);
            System.out.println(myProperties);
    
        }
    
        public String[] getMyStrs() {
            return myStrs;
        }
    
        public void setMyStrs(String[] myStrs) {
            this.myStrs = myStrs;
        }
    
        public List<String> getMyList() {
            return myList;
        }
    
        public void setMyList(List<String> myList) {
            this.myList = myList;
        }
    
        public Set<String> getMySet() {
            return mySet;
        }
    
        public void setMySet(Set<String> mySet) {
            this.mySet = mySet;
        }
    
        public Map<String, String> getMyMap() {
            return myMap;
        }
    
        public void setMyMap(Map<String, String> myMap) {
            this.myMap = myMap;
        }
    
        public Properties getMyProperties() {
            return myProperties;
        }
    
        public void setMyProperties(Properties myProperties) {
            this.myProperties = myProperties;
        }
    }

public static void main(String[] args) {
    
            //1.获取核心容器对象
    //        ApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
            ClassPathXmlApplicationContext ac=new ClassPathXmlApplicationContext("bean.xml");
    
            //2.根据id获取Bean对象
    //        IAccountService as=(IAccountService)ac.getBean("accountServi ce");
    //        as.saveAccount();
    
    //          IAccountService as=(IAccountService)ac.getBean("accountService2");
    //          as.saveAccount();
    
            IAccountService as=(IAccountService)ac.getBean("accountService3");
            as.saveAccount();
        }

结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA3MDQ3Mw_size_16_color_FFFFFF_t_70 5][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA3MDQ3Mw_size_16_color_FFFFFF_t_70]: /images/20221119/0a293734ada8478d941e352464bb5c41.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA3MDQ3Mw_size_16_color_FFFFFF_t_70 1]: /images/20221119/aa3cfe5f49c04588bfb3b4ff0888d8ac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA3MDQ3Mw_size_16_color_FFFFFF_t_70 2]: /images/20221119/bbab5e15779b4cb7be5403e53b497a1d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA3MDQ3Mw_size_16_color_FFFFFF_t_70 3]: /images/20221119/8b232ab27f474281b78b91096effff27.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA3MDQ3Mw_size_16_color_FFFFFF_t_70 4]: /images/20221119/c57bb4cc43724aa1be509ad531a521d8.png
[20210109131739596.png]: /images/20221119/63b0fafb716a4deca596d33473eca856.png
[20210109132122793.png]: /images/20221119/cfd68a85f5264a1684945a904d38b9ab.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA3MDQ3Mw_size_16_color_FFFFFF_t_70 5]: /images/20221119/e379ad08646e4a85ad1c188884982195.png