Spring ioc 学习笔记

Spring是什么:
Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核。

提供了展现层 SpringMVC和持久层 Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架

Spring的优势

方便解耦，简化开发

AOP 编程的支持

声明式事务的支持

方便程序的测试

Spring的体系结构

下面都是以代码的形式展示,里面都有配置

serviceImpl实现层,(所有内容都共用.)

package cn.clx.service.impl;

import cn.clx.dao.UserDao;
import cn.clx.service.UserService;

/**
 * @Description: TODO
 * @Author CLX
 * @Date 2019/11/4
 * @Version V1.0
 **/
public class UserServiceImpl implements UserService {
    private UserDao userDao;
//第一种带参构造方法,bean依赖注入
   /* public UserServiceImpl( UserDao userDao ) {
        this.userDao = userDao;
    }*/

   //第二种模式bean依赖注入 set方法
    public void setUserDao( UserDao userDao ) {
        this.userDao = userDao;
    }

    @Override
    public void save() {
        userDao.save();
    }
}

userDaoImpl实现层

package cn.clx.dao.impl;

import cn.clx.dao.UserDao;
import cn.clx.domain.User;

import java.util.List;
import java.util.Map;
import java.util.Properties;

/**
 * @Description: TODO
 * @Author CLX
 * @Date 2019/11/4
 * @Version V1.0
 **/
public class UserDaoImpl implements UserDao {
    //set方法
    private String name ;
    private int age ;
    private List<String> strList;
    private Map<String, User> userMap;
    private Properties props;

    public void setProps( Properties props ) {
        this.props = props;
    }

    public void setName( String name ) {
        this.name = name;
    }

    public void setAge( int age ) {
        this.age = age;
    }

    public void setStrList( List<String> strList ) {
        this.strList = strList;
    }

    public void setUserMap( Map<String, User> userMap ) {
        this.userMap = userMap;
    }

    public UserDaoImpl() {
        System.out.println("孔构造执行了/...");
    }

    @Override
    public void save() {
        System.out.println("save...");
        System.out.println("name..."+name);
        System.out.println("age..."+age);
        System.out.println("list..."+strList);
        System.out.println("userMap..."+userMap);
        System.out.println("props..."+props);
    }
}

配置: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"
       xmlns:p = "http://www.springframework.org/schema/p"
       xsi:schemaLocation="
    http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans.xsd">


    <!--bean依赖注入方式第一种,构造方法 带参模式-->
    <!--<bean id="userDao" class="cn.clx.dao.impl.UserDaoImpl"/>
    <bean id="userService" class="cn.clx.service.impl.UserServiceImpl">
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
    </bean>-->

    <!--bean依赖注入第二种方式,使用set方式注入-->
    <!--<bean id="userDao" class="cn.clx.dao.impl.UserDaoImpl"/>
    <bean id="userService" class="cn.clx.service.impl.UserServiceImpl">
        <property name="userDao" ref="userDao"/> &lt;!&ndash;使用的是引用类型&ndash;&gt;
    </bean>
-->

    <!--第三种 标签引用方式.本质也是set方法注入 主要是比set方法比较简便一点
    xmlns:p = "http://www.springframework.org/schema/p" 只需要在上面引入约束就可以了-->
    <!--<bean id="userDao" class="cn.clx.dao.impl.UserDaoImpl"/>
    <bean id="userService" class="cn.clx.service.impl.UserServiceImpl" p:userDao-ref="userDao"/>-->

    <!--............................分割线.........................................-->
    <!--第一种bean实例化模式-->
    <!-- <bean id="userDao" class="cn.clx.dao.impl.UserDaoImpl"/>-->

    <!--第二种Bean实例化模式 工厂静态方法实例-->
    <!-- <bean id="userDao" class="cn.clx.bean.FactoryBean" factory-method="getUserDao"/>-->


    <!--第三种工厂实例方法实例化   工厂的非静态方法返回Bean实例-->
    <!-- <bean id="factoryBean" class="cn.clx.bean.FactoryBean2"/>
     <bean id="userDao" factory-bean="factoryBean" factory-method="getUserDao"/>-->

    <!--...............................分割线......................................-->

    <!--Bean依赖注入数据类型-->
    <!--基本类型.string -->
    <!--<bean id="userDao" class="cn.clx.dao.impl.UserDaoImpl">
        <property name="name" value="lili"/>
        <property name="age" value="13"/>
    </bean>-->

    <!--集合类型的一种类型-->
    <!--<bean id="userDao" class="cn.clx.dao.impl.UserDaoImpl">
        <property name="strList">
            <list>
                <value>111</value>
                <value>222</value>
                <value>333</value>
            </list>
        </property>
    </bean>-->
    <!--集合数据类型(复杂数据类型) 包含引用类型-->
    <!--<bean id="u1" class="cn.clx.domain.User"/>
    <bean id="u2" class="cn.clx.domain.User"/>
    <bean id="userDao" class="cn.clx.dao.impl.UserDaoImpl">
        <property name="userMap">
            <map>
                <entry key="user1" value-ref="u1"/>
                <entry key="user2" value-ref="u2"/>
            </map>
        </property>
    </bean>-->
    <!--properties 集合数据类型-->
    <bean id="userDao" class="cn.clx.dao.impl.UserDaoImpl">
        <property name="props">
            <props>
                <prop key="p1">ppp</prop>
                <prop key="p2">ppp2</prop>
            </props>
        </property>
    </bean>

</beans>

测试代码:

import cn.clx.dao.UserDao;
import cn.clx.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @Description: TODO
 * @Author CLX
 * @Date 2019/11/4
 * @Version V1.0
 **/
public class testt {
    /**
     * applicationContext.xml 配置
     * <bean id="userDao" class="cn.clx.dao.impl.UserDaoImpl" scope="singleton"/>
     * scope="singleton" :如果配置了是prototype那么就是懒加载模式. getBean的时候创建. 单列模式
     * 单例模式正常scope可以不用写,默认值
     * Bean的实例化个数：1个
     * Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例
     */
    @Test
    public void test1() {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); 孔构造执行了/...
        UserDao userDao = app.getBean(UserDao.class); //这个只能指定一个不能多个区分.
        //  UserDao userDao = (UserDao) app.getBean("userDao");//这个可以在applicationContext.xml配置可以根据id不同进行分配
        System.out.println(userDao);//cn.clx.dao.impl.UserDaoImpl@458c1321
        userDao.save();
    }

    /**
     * applicationContext.xml 配置
     * <bean id="userDao" class="cn.clx.dao.impl.UserDaoImpl" scope="prototype"/>
     * scope="prototype" :如果配置了是prototype那么就是懒加载模式. getBean的时候创建. 多例模式
     * Bean的实例化个数：多个
     * Bean的实例化时机：当调用getBean()方法时实例化Bean
     */
    @Test
    public void test2() {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) app.getBean("userDao"); // 孔构造执行了/...
        UserDao userDao2 = (UserDao) app.getBean("userDao");// 孔构造执行了/...
        System.out.println(userDao);//cn.clx.dao.impl.UserDaoImpl@1f57539
        System.out.println(userDao2);//cn.clx.dao.impl.UserDaoImpl@76f2b07d

    }

    /**
     * applicationContext.xml配置
     * <!--第二种Bean实例化模式 工厂的静态方法返回Bean实例-->
     * <bean id="userDao" class="cn.clx.bean.FactoryBean" factory-method="getUserDao"/>
     */
    @Test
    public void test3() {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) app.getBean("userDao");
        userDao.save();
    }


    /**
     * applicationContext.xml配置
     * <!--第三种Bean工厂实例方法实例化 工厂的非静态方法返回Bean实例-->
     * <bean id="userDao" class="cn.clx.bean.FactoryBean" factory-method="getUserDao"/>
     */
    @Test
    public void test4() {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) app.getBean("userDao");
        userDao.save();
    }

    /**
     * bean 依赖注入模式
     * 创建带参构造方法传入
     * <!--bean依赖注入方式第一中,构造方法 带参模式-->
     *     <bean id="userDao" class="cn.clx.dao.impl.UserDaoImpl"/>
     *     <bean id="userService" class="cn.clx.service.impl.UserServiceImpl" >
     *         <constructor-arg name="userDao" ref="userDao" ></constructor-arg>
     *     </bean>
     */
    @Test
    public void test5() {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");//孔构造执行了/...
        UserService userDao = (UserService) app.getBean("userService");
        userDao.save();//save...
    }


    /**
     *   <!--bean依赖注入第二种方式,使用set方式注入--> applicationContext.xml配置
     *     <bean id="userDao" class="cn.clx.dao.impl.UserDaoImpl"/>
     *     <bean id="userService" class="cn.clx.service.impl.UserServiceImpl">
     *         <property name="userDao" ref="userDao"/> <!--使用的是引用类型-->
     *     </bean>
     */
    @Test
    public void test6() {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");//孔构造执行了/...
        UserService userDao = (UserService) app.getBean("userService");
        userDao.save();//save...
    }

    /**
     * bean引入的数据类型分三种 ,第一种
     *  <!--基本类型.string -->
     *     <bean id="userDao" class="cn.clx.dao.impl.UserDaoImpl">
     *         <property name="name" value="lili"/>
     *         <property name="age" value="13"/>
     *     </bean>
     */
    @Test
    public void test7() {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); 孔构造执行了/...
        UserDao userDao = (UserDao) app.getBean("userDao");
        System.out.println(userDao);//cn.clx.dao.impl.UserDaoImpl@458c1321
        userDao.save(); //name...lili age...13
    }
    /**
     * bean引入的数据类型分三种 ,第一种
     *  <!--集合类型 list类型-->
     *     <bean id="userDao" class="cn.clx.dao.impl.UserDaoImpl">
     *         <property name="strList">
     *             <list>
     *                 <value>111</value>
     *                 <value>222</value>
     *                 <value>333</value>
     *             </list>
     *         </property>
     *     </bean>
     *
     *
     */
    @Test
    public void test8() {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); 孔构造执行了/...
        UserDao userDao = (UserDao) app.getBean("userDao");
        System.out.println(userDao);//cn.clx.dao.impl.UserDaoImpl@458c1321
        userDao.save(); //name...lili age...13
    }

    /**
     * <!--集合数据类型(复杂数据类型) 包含引用类型-->
     *     <bean id="u1" class="cn.clx.domain.User"/>
     *     <bean id="u2" class="cn.clx.domain.User"/>
     *     <bean id="userDao" class="cn.clx.dao.impl.UserDaoImpl">
     *         <property name="userMap">
     *             <map>
     *                 <entry key="user1" value-ref="u1"/>
     *                 <entry key="user2" value-ref="u2"/>
     *             </map>
     *         </property>
     *     </bean>
     */
    @Test
    public void test9() {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); 孔构造执行了/...
        UserDao userDao = (UserDao) app.getBean("userDao");
        System.out.println(userDao);//cn.clx.dao.impl.UserDaoImpl@458c1321
        userDao.save(); //因为没有赋值所以只有对象出来而已
    }

    /**
     *<!--properties 集合数据类型-->
     *     <bean id="userDao" class="cn.clx.dao.impl.UserDaoImpl">
     *         <property name="props">
     *             <props>
     *                 <prop key="p1">ppp</prop>
     *                 <prop key="p2">ppp2</prop>
     *             </props>
     *         </property>
     *     </bean>
     */
    @Test
    public void test10() {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml"); 孔构造执行了/...
        UserDao userDao = (UserDao) app.getBean("userDao");
        System.out.println(userDao);//cn.clx.dao.impl.UserDaoImpl@458c1321
        userDao.save(); //props...{p2=ppp2, p1=ppp}
    }
}

里面是学习到内容在这里做记录,基本都有写注解.内容比较简单,比较乱 谅解谅解