Spring框架基础（上）

  • spring是开源对轻量级框架
  • spring核心主要两部分
    • aop
      • 面向切面编程，扩展功能不是修改源代码实现
      • aop采用横向抽取机制，取代了传统纵向继承体系重复代码（性能监视、事务管理、安全检查、缓存）
      • 使用动态代理方式实现横向抽取机制
        • 　　使用JDK动态代理，针对有接口情况
        • 　　创建接口类的平级对象
        •       这个对象不是真正对象，是代理对象，实现和类相同的功能
        • 　　使用cglib动态代理，针对没有接口情况
          • 创建类的子类的代理对象
          • 在子类里面调用父类的方法完成增强
      • aop操作术语
        • Joinnoint（连接点）
          • 所谓连接点是指那些被拦截到的点。在spring中，这些点指的是方法，因为spring只支持方法类型的连接点
          • 类里面那些方法可以被增强，这些方法称为连接点
        • Pointcut（切入点）
          • 所谓切入点是指我们要对那些Joinnoint进行拦截的定义
          • 在类里面可以有很多的方法被增强，而实际增强的方法称为切入点
        • Advice（通知/增强）
          • 所谓通知是指拦截到Joinnoint之后所要做的事情就是通知
          • 通知分类
            • 前置通知：在方法之前执行
            • 后置通知：在方法之后执行
            • 异常通知：方法出现异常
            • 最终通知：在后置之后执行
            • 环绕通知：在方法之前和之后执行
          • 功能扩展的逻辑，称为增强。
        • Introduction（引介）
          • 引介是一种特殊的通知在不修改类代码的前提下，Introduction可以在运行期为类动态地添加一些方法或Field
        • Target（目标对象）
          • 代理的目标对象（要增强的类）
          • 增强方法所在的类，叫做目标对象
        • Weaving（织入）
          • 是把增强应用到目标的过程
          • 把advice应用到target的过程
        • Proxy（代理）
          • 一个类被ACP织入增强后，就产生一个结果代理类
        • Aspect（切面）
          • 是切入点和通知（引介）的结合
          • 把增强应用到具体方法上面，过程称为切面
      • AspectJ
        • AspectJ是一个基于Java语言的AOP框架
        • AspectJ是一个面向切面的框架，它扩展了Java语言
        • AspectJ定义了aop语法，所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件
        • AspectJ实现aop
        • 导入jar包spring-aop-4.3.5.RELEASE.jar、spring-aspects-4.3.5.RELEASE.jar、aspectjweaver-1.9.2.jar、aopalliance-1.0.jar
        • 导入约束 
          <?xml version="1.0" encoding="UTF-8" ?>
<!--
    http://www.springframework.org/schema/context/spring-context.xsd：用于注解的约束
    http://www.springframework.org/schema/aop/spring-aop.xsd：用于aop的约束
 -->
<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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

</beans>
        • 具体实现
          • 基于aspectJ的xml配置 
            /**
 * 
 */
public class Test02 {

    public void test02() {
        System.out.println("前置增强");
    }
    public void test02After(){
        System.out.println("后置增强");
    }
    /**
     *
     * @param proceedingJoinPoint 被增强的的方法
     */
    public void test02Around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕增强前");
        proceedingJoinPoint.proceed();
        System.out.println("环绕增强后");
    }

}




/**
 * 
 */
public class Test01 {

    public void test01(){
        System.out.println("切入点");
    }
}




<!-- 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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置对象 -->
    <bean id="test01" class="cn.muriel.auto.aop.Test01"/>
    <bean id="test02" class="cn.muriel.auto.aop.Test02"/>

    <!-- 配置aop操作 -->
    <aop:config>
        <!--
            配置切入点(*代表匹配所有)
            execution(<访问修饰符> ? <返回类型><方法名>(<参数>)<异常>)
            execution(* cn.muriel.auto.aop.Test01.test01(..))
            execution(* cn.muriel.auto.aop.Test01.*(..))
            execution(* *.*(..))
            execution(* save*(..))//匹配所有save开头的方法
        -->
        <aop:pointcut id="pointcut1" expression="execution(* cn.muriel.auto.aop.Test01.test01(..))"/>
        <!-- 配置增强类型 -->
        <aop:aspect ref="test02">
            <!--
                配置增强类型
                method：增强类里面使用哪个方法作为前置
             -->
            <!-- 前置增强 -->
            <aop:before method="test02" pointcut-ref="pointcut1"/>
            <!-- 后置增强 -->
            <aop:after-returning method="test02After" pointcut-ref="pointcut1"/>
            <!-- 环绕增强 -->
            <aop:around method="test02Around" pointcut-ref="pointcut1"/>
     </aop:aspect>
    </aop:config>

</beans>




/**
 *  测试代码
 */
public class TestUtil {


    public static void main(String[] args) {


        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("aop/aop.xml");


        Test01 test01 = (Test01) applicationContext.getBean("test01");
        test01.test01();
    
    }
}

             

          • 基于aspectJ的注解方式 
            @Aspect
public class Test02 {

    @Before(value = "execution(* cn.muriel.auto.aop.Test01.test01(..))")
    public void test02() {
        System.out.println("前置增强");
    }

    @AfterReturning(value = "execution(* cn.muriel.auto.aop.Test01.test01(..))")
    public void test02After(){
        System.out.println("后置增强");
    }

    /**
     *
     * @param proceedingJoinPoint 被增强的的方法
     */
    @Around(value = "execution(* cn.muriel.auto.aop.Test01.test01(..))")
    public void test02Around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕增强前");
        proceedingJoinPoint.proceed();
        System.out.println("环绕增强后");
    }

}



/**
 * 
 */
public class Test01 {

    public void test01(){
        System.out.println("切入点");
    }
}




<!-- 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:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       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
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

  <!-- 开启aop操作 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>


    <!-- 配置对象 -->
    <bean id="test01" class="cn.muriel.auto.aop.Test01"/>
    <bean id="test02" class="cn.muriel.auto.aop.Test02"/>


</beans>




/**
 *  测试代码
 */
public class TestUtil {


    public static void main(String[] args) {


        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("aop/aop.xml");


        Test01 test01 = (Test01) applicationContext.getBean("test01");
        test01.test01();
    
    }
}

             

    • ioc
      • 控制反转，把对象对创建不是通过new方式实现，而是交给spring配置创建类对象
      • IOC和DI区别
        • IOC：控制反转，把对象创建交给spring进行配置
        • DI：依赖注入，向类里面的属性中设置值
        • IOC和DI关系
          • 依赖注入不能单独存在，需要在ioc基础之上完成操作
      • ioc操作
        • ioc的配置文件方式 
          <!-- 配置文件 -->
    <?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="userService" class="cn.xxx.auto.service.UserService"/>

    </beans>


<!-- 测试代码 -->
public class TestUtil {

    private static ApplicationContext applicationContext;

    public static void main(String[] args) {


        applicationContext = new ClassPathXmlApplicationContext("service/service.xml");

        UserService userService = (UserService) applicationContext.getBean("userService");

        userService.test();
       

    }
        • ioc的注解方式
          • 什么是注解
            • 代码里面特殊标记，使用注解可以完成功能
          • 注解的写法
            • @注解名称(属性名称=属性值)
          • 注解的使用范围
            • 类
            • 方法
            • 属性
          • 常用注解
            • @Controller：WEB层
            • @Service：业务层
            • @Repository：持久层
            • @Component：类
          • 注解创建对象
            <!-- 导入基本的jar包和aop.jar包 -->
<!-- 创建类、方法 -->



<!--  创建spring配置文件，引入约束 -->

<?xml version="1.0" encoding="UTF-8" ?>
<!--
    http://www.springframework.org/schema/context/spring-context.xsd：用于注解的约束
 -->
<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 definitions here -->


    <!--
        开启注解扫描：到包里面扫描类、方法、属性上面是否有注解
    -->
    <context:component-scan base-package="cn.xxx.auto.pojo"/>
    
    <!--
       开启注解扫描：扫描属性上面的注解

    <context:annotation-config></context:annotation-config>-->
</beans>



/**
 * 注解创建对象：在创建对象的类上面使用注解实现
 */
@Component(value="user") //相当于<bean id="user" class="" />
@Scope(value="prototype")//默认为单实例，prototype为多实例
public class User {

    public void test(){
        System.out.println("创建成功");
    }
}

/**
 * 测试代码
 */
public class TestUtil {


    public static void main(String[] args) {

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("pojo/pojo.xml");

        User user = (User) applicationContext.getBean("user");

        user.test();
}

             

          • 注解注入属性（Autowired） 
            <!-- -->
<?xml version="1.0" encoding="UTF-8" ?>
<!--
    http://www.springframework.org/schema/context/spring-context.xsd：用于注解的约束
 -->
<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">
    <!-- 导入文件 -->
    <import resource="classpath:dao/dao.xml"/>
    <import resource="classpath:pojo/pojo.xml"/>


    <context:component-scan base-package="cn.xxx.auto.service"></context:component-scan>
    <!--<bean id="userService" class="cn.xxx.auto.service.UserService">-->
    <!--
        注入dao对象：
        name：service类里面属性名称
        value：赋值给name的字符串
        ref：赋值给name的对象，配置bean的id值

    <property name="userDao" ref="userDao"/>
</bean>-->

</beans>



/**
*
*/
@Component(value = "userService")
public class UserService {

    //在dao属性上面使用注解完成对象注入
    @Autowired
    private UserDao userDao;

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

    public void addUser(User user) {

        userDao.insert(user);
    }
}


/**
*
*/
public class TestUtil {


    public static void main(String[] args) {

     
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("service/service.xml");


        UserService userService = (UserService) applicationContext.getBean("userService");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        User user = (User) applicationContext.getBean("user");


        userService.setUserDao(userDao);



        userService.addUser(user);


       
    }

             

          • 注解注入属性（Resource）
            <!-- -->
<?xml version="1.0" encoding="UTF-8" ?>
<!--
    http://www.springframework.org/schema/context/spring-context.xsd：用于注解的约束
 -->
<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">
    <!-- 导入文件 -->
    <import resource="classpath:dao/dao.xml"/>
    <import resource="classpath:pojo/pojo.xml"/>


    <context:component-scan base-package="cn.xxx.auto.service"></context:component-scan>
    <!--<bean id="userService" class="cn.xxx.auto.service.UserService">-->
    <!--
        注入dao对象：
        name：service类里面属性名称
        value：赋值给name的字符串
        ref：赋值给name的对象，配置bean的id值

    <property name="userDao" ref="userDao"/>
</bean>-->

</beans>



/**
*
*/
@Repository(value = "userDao")
public class UserDao  implements UserMapper {

}




/**
*
*/
@Component(value = "userService")
public class UserService {

   //在dao属性上面使用注解完成对象注入
    //name属性值写注解创建dao对象的value值
    @Resource(name = "userDao")
    private UserDao userDao;


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

    public void addUser(User user) {

        userDao.insert(user);
    }
}


/**
*
*/
public class TestUtil {


    public static void main(String[] args) {

     
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("service/service.xml");


        UserService userService = (UserService) applicationContext.getBean("userService");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        User user = (User) applicationContext.getBean("user");


        userService.setUserDao(userDao);



        userService.addUser(user);


       
    }

             

      • ioc底层原理使用技术
        • xml配置文件
        • dom4j解决xml
        • 工厂设计模式
        • 反射  
          /**
 * ioc底层原理
 */
public class UserFactory {


    private String serviceId = "userService";

    /**
     * （1）使用dom4j解析xml方法
     * （2）使用反射创建对象
     *
     * @return 返回UserService对象的方法
     */
    public UserService getUserService() {
        //导入dom4j.jar
        SAXReader saxReader = new SAXReader();

        //获取指定xml文件
        URL url = this.getClass().getClassLoader().getResource("service/service.xml");
        try {
            Document document = saxReader.read(url);
            //获取根结点
            Element rootElement = document.getRootElement();

            //获取根结点下的子节点
            List elements = rootElement.elements();
            String serviceClass = "";
            //遍历取出子节点
            for (int i = 0; i < elements.size(); i++) {
                //获取子节点
                Element element = (Element) elements.get(i);
                //获取子节点下的参数
                Attribute idAttribute = element.attribute("id");
                Attribute classAttribute = element.attribute("class");

                if (serviceId.equals(idAttribute.getValue())) {
                    serviceClass = classAttribute.getValue();
                    break;
                }
            }

            System.out.println(serviceClass);

            Class<?> newClass = Class.forName(serviceClass);

            return (UserService) newClass.newInstance();
        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }


        return null;
    }


     /**
     * 测试
     * @param args
     */
    public static void main(String[] args) {
        UserFactory service = new UserFactory();
        UserService userService = service.getUserService();
        userService.test();
    }
}
  • spring是一站式框架
    • spring在javaee三层架构中，每一层都提供不同的解决技术
      • web层：SpringMvc
      • service层：spring的ioc
      • dao层：spring的jdbcTemplate
  • spring入门（ioc，service的创建）
    • 导入jar包
      • 做spring最基本功能时,只需要导入beans、core、context、expression这四个jar包
      • 导入支持日志输出的jar包，commons-logging-1.2.jar
    • 创建类，在类里面创建方法 
      public class UserService  {

    public void test(){
        System.out.println("获取成功");
    }
}
    • 创建spring配置文件，配置创建类
      • 建议放到src下面，官方建议applicationContext.xml
      • 引入schema约束（spring/framework/reference/html/xsd-configuration.html）
    • 写代码测试对象创建
  • spring的bean管理（xml配置文件）
    • bean是实例化的方式
      • 使用类的无参数构造创建 
        <bean id="user" class="cn.xxx.auto.pojo.User"/>
      • 使用静态工厂创建 
        public class UserFactory  {


    public static User getUser() {

        return new User();
    }


}


<!-- 配置文件 -->
<!-- 
        destroy-method：静态工厂中的静态方法
    -->
    <bean id="user" class="cn.xxx.auto.factory.UserFactory" destroy-method="getUser"/>
      • 使用实例工厂创建 
        public class UserFactory  {


    public User getUser() {

        return new User();
    }


}


<!-- 配置文件 -->
<!-- 
        factory-bean：实例工厂中的对象
        factory-method：实例工厂中的方法
    -->
    <bean id="userFactory" class="cn.xxx.auto.factory.UserFactory" destroy-method="getUser"/>
    <bean id="user" factory-bean="userFactory" factory-method="getUser" />
    • bean标签常用属性
      • id属性
        • 起名称，id属性名称任意命名。
        • 通过id值得到配置对象
      • class属性
        • 创建对象所在类的全路径
      • name属性
        • 功能与id属性一样
        • 与id属性区别在于，id不可以包含特殊符号
      • scope属性
        • singleton：默认值。单例。获取都是同一个对象
        • prototype：多例。获取是不同对象
        • request：创建对象把对象放到request域里面
        • session：创建对象把对象放到session域里面
        • globalSession：创建对象把对象放到globalSession域里面
    • 属性注入方式  
      • 使用set方法注入 
        /**
* 测试代码
*/
public class TestUtil {

　　private String obj;
        
            public void setObj(String obj) {
        this.obj = obj;
    }
            public void test(){
        　　    System.out.println("obj="+obj);
            }
 
             public static void main(String[] args) {


            TestUtil testUtil = new TestUtil();
                    testUtil.setObj("obj");
                    test();
    }
}


          <!-- 使用有参数构造注入属性 -->
    <bean id="user" class="cn.muriel.mybatis.utils.TestUtil">
        <!-- 使用有参构造注入 -->
        <property name="obj" value="obj"/>
    </bean>
      • 有参数构造注入 
        /**
* 测试代码
*/
public class TestUtil {


    public TestUtil(String obj) {
        System.out.println(obj);
    }
 
     public static void main(String[] args) {


            TestUtil testUtil = new TestUtil("obj");
    }
}


  <!-- 使用有参数构造注入属性 -->
    <bean id="user" class="cn.muriel.mybatis.utils.TestUtil">
        <!-- 使用有参构造注入 -->
        <constructor-arg name="obj" value="obj"/>
    </bean>
      • 使用接口注入（spring不支持）
    • spring注入属性（有参构造和set方法）
    • spring注入对象类型属性 
      <?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="userDao" class="cn.xxx.auto.dao.UserDao"></bean>

</beans>



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

    <!-- 导入文件 -->
    <import resource="classpath:dao/dao.xml"/>


    <bean id="userService" class="cn.xxx.auto.service.UserService">
        <!--
            注入dao对象：
            name：service类里面属性名称
            value：赋值给name的字符串
            ref：赋值给name的对象，配置bean的id值
        -->
        <property name="userDao" ref="userDao"/>
    </bean>

</beans>


public class UserService {

    //声明mapper对象
    private UserDao userDao;

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

    public void addUser() {

        System.out.println("测试");
    }
}



/**
* 测试代码
*/
public class TestUtil {


    public static void main(String[] args) {


    

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("service/service.xml");
        UserService userService = (UserService) applicationContext.getBean("userService");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");




        userService.setUserDao(userDao);

        userService.addUser();
    }

}
    • p名称空间注入 
      <?xml version="1.0" encoding="UTF-8" ?>
<!-- 
      引入名称空间p：xmlns:p="http://www.springframework.org/schema/p"
 -->
<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 id="userDao" class="cn.xxx.auto.dao.UserDao"></bean>

</beans>



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

    <!-- 导入文件 -->
    <import resource="classpath:dao/dao.xml"/>


    <bean id="userService" class="cn.xxx.auto.service.UserService" p:pname-ref="userDao>
      
    </bean>

</beans>


public class UserService {

    //声明mapper对象
    private UserDao userDao;

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

    public void addUser() {

        System.out.println("测试");
    }
}



/**
* 测试代码
*/
public class TestUtil {


    public static void main(String[] args) {


    

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("service/service.xml");
        UserService userService = (UserService) applicationContext.getBean("userService");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");




        userService.setUserDao(userDao);

        userService.addUser();
    }

}
    • spring注入复杂数据
      • 数组
      • list集合
      • map集合
      • 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="userDao" class="cn.xxx.auto.dao.UserDao"></bean>

</beans>



<?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="userService" class="cn.xxx.auto.service.UserService">
        <!--
           arrs：
        -->
        <property name="arrs">
                <list>
                    <value>1</value>
                    <value>2</value>
                    <value>3</value>
                </list>
        </property>
        <!--
           list：
        -->
       <property name="list">
                <list>
                    <value>11</value>
                    <value>22</value>
                    <value>33</value>
                </list>
        </property>
        <!--
           map：
        -->
        <property name="map">
                <map>
                    <entry key="username" value="aa"></entry>
                    <entry key="password" value="bb"></entry>
                </map>
        </property>
        <!--
           
        -->
        <property name="properties">
                <props>
                    <prop key="username">aa</prop>
                    <prop key="password">bb</prop>
                </list>
        </property>

    </bean>

</beans>


public class UserService {

   
    private String[] arrs;
    private List<String> list;
    private Map<String,String> map;
    private Properties properties;


    public void setArrs(String[] arrs) {
        this.arrs = arrs;
    }
    public void setList(List<String> list) {
        this.list = list;
    }
    public void setMap(Map<String,String> map) {
        this.map = map;
    }
    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void addUser() {

        System.out.println("arrs="+arrs);
        System.out.println("list="+list);
        System.out.println("map="+map);
        System.out.println("properties="+properties);
    }
}



/**
* 测试代码
*/
public class TestUtil {


    public static void main(String[] args) {


    

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("service/service.xml");
        UserService userService = (UserService) applicationContext.getBean("userService");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");




        userService.setUserDao(userDao);

        userService.addUser();
    }

}
posted @ 2019-03-19 01:19  好胖的兔子  阅读(215)  评论(0)  编辑  收藏  举报