Spring框架基础（上）

spring是开源对轻量级框架

spring核心主要两部分

面向切面编程，扩展功能不是修改源代码实现
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();

    }

}

Spring框架基础（上）的更多相关文章

Spring框架基础2
Spring框架基础2 测试Spring的AOP思想和注解的使用导包(在前面的基础上添加) SpringAOP名词解释 AOP编程思想:横向重复代码,纵向抽取:就是说多个地方重复的代码可以抽取出来公 ...
Spring学习指南-第二章-Spring框架基础(完)
第二章 Spring框架基础面向接口编程的设计方法在上一章中,我们看到了一个依赖于其他类的POJO类包含了对其依赖项的具体类的引用.例如,FixedDepositController 类包含 ...
4-1 Spring框架基础知识
Spring框架基础知识 1.Spring 框架作用主要解决了创建对象和管理对象的问题. 自动装配机制 2.Spring 框架 (Spring容器,JavaBean容器,Bean容器,Spring容 ...
如何基于Winform开发框架或混合框架基础上进行项目的快速开发
在开发项目的时候,我们为了提高速度和质量,往往不是白手起家,需要基于一定的基础上进行项目的快速开发,这样可以利用整个框架的生态基础模块,以及成熟统一的开发方式,可以极大提高我们开发的效率.本篇随笔就是 ...
Spring框架基础知识
本人博客文章网址:https://www.peretang.com/basic-knowledge-of-spring-framework/ Spring框架简介 Spring , 一个开源的框架 , ...
Spring框架基础
1 Spring框架 1.1 Spring的基本概念是一个轻量级的框架,提供基础的开发包,包括消息.web通讯.数据库.大数据.授权.手机应用.session管理 ...
Spring 框架基础(04)：AOP切面编程概念，几种实现方式演示
本文源码:GitHub·点这里 || GitEE·点这里一.AOP基础简介 1.切面编程简介 AOP全称:Aspect Oriented Programming,面向切面编程.通过预编译方式和运行期 ...
【JavaEE】SSH+Spring Security基础上配置AOP+log4j
Spring Oauth2大多数情况下还是用不到的,主要使用的还是Spring+SpringMVC+Hibernate,有时候加上SpringSecurity,因此,本文及以后的文章的example中 ...
Spring 框架基础(06)：Mvc架构模式简介，执行流程详解
本文源码:GitHub·点这里 || GitEE·点这里一.SpringMvc框架简介 1.Mvc设计理念 MVC是一种软件设计典范,用一种业务逻辑.数据.界面显示分离的方法组织代码,将业务逻辑聚集 ...
Spring 框架基础(01)：核心组件总结，基础环境搭建
本文源码:GitHub·点这里 || GitEE·点这里一.Spring框架 1.框架简介 Spring是一个开源框架,框架的主要优势之一就是其分层架构,分层架构允许使用者选择使用哪一个组件,同时为 ...

随机推荐

Android图标
在线生成安卓App图标.IOS App图标 https://icon.wuruihong.com
【错误解决】Intellj（IDEA） warning no artifacts configured
: warning no artifacts configured,,上面木有Artifacts的选项,,好尴尬, [解决方案]artifacts,是maven中的概念(项目是maven项目),由于没 ...
VUE插件大总结
UI组件 element - 饿了么出品的Vue2的web UI工具套件 Vux - 基于Vue和WeUI的组件库 mint-ui - Vue 2的移动UI元素 iview - 基于 Vuejs 的开 ...
[Swift]LeetCode90. 子集 II | Subsets II
Given a collection of integers that might contain duplicates, nums, return all possible subsets (the ...
[Swift]LeetCode563. 二叉树的坡度 | Binary Tree Tilt
Given a binary tree, return the tilt of the whole tree. The tilt of a tree node is defined as the ab ...
[Swift]LeetCode565. 数组嵌套 | Array Nesting
A zero-indexed array A of length N contains all integers from 0 to N-1. Find and return the longest ...
[Swift]LeetCode1010. 总持续时间可被 60 整除的歌曲 | Pairs of Songs With Total Durations Divisible by 60
In a list of songs, the i-th song has a duration of time[i] seconds. Return the number of pairs of s ...
Python---第3方库
使用pip命令安装 pip -h 查看pip使用帮助 pip install <第3方库名> pip install -U <第3方库名> 对已安装的第三方库更新 pi ...
JSON 序列化的时候忽略无效的属性值
例如我拥有以下代码. public class NewObject { public int? TestValue { get; set; } public int? Age { get; set; ...
强如 Disruptor 也发生内存溢出？
前言 OutOfMemoryError 问题相信很多朋友都遇到过,相对于常见的业务异常(数组越界.空指针等)来说这类问题是很难定位和解决的. 本文以最近碰到的一次线上内存溢出的定位.解决问题的方式展开 ...

Spring框架基础（上）

Spring框架基础（上）的更多相关文章

随机推荐

热门专题