spring-01

spring-01

1、spring的简介
　　Spring 是一个开源框架，为简化企业级应用开发而生。Spring 可以使简单的 JavaBean 实现以前只有 EJB 才能实现的功能。Spring 是一个 IOC 和 AOP 容器框架。
IOC容器：控制反转， 反转控制， 反向控制
　　将对象的生命周期控制权利，交给Spring容器管理。原有开发方式，对象生命周期由程序员通过代码控制.。如: new关键字. setter方法调用, xxx = null.
1）控制反转中控制指的是：控制类的对象
2）控制反转中反转指的是转交给 Spring 负责
3）IoC 最大的作用：解耦(程序员不需要管理对象.解除了对象管理和程序员之间的耦合)
2、Spring的DI：依赖注入
　　当一个类(A)中需要依赖另一个类(B)对象时，把 B 赋值给 A 的过程就叫做依赖注入
3、spring的注入的种类和方式
1）构造方法注入（通过构造方法的参数,为对象的属性赋值）
2）setter注入（Spring容器针对bean对象的property实现属性注入.面向getter方法和setter方法实现的属性数据赋值. 每次为属性赋值,调用的是setXxxx方法）
3）静态工厂的方法注入
4）实例工厂的方法注入

//字符串注入
private String msg;
//int类型注入
private int flag;
//String类型数组注入    
private String[] array;
//int类型数组注入
private int[] array2;
//list注入
private List<String> list;
//其他对象类型
private List<UserDao> uds;
//set
private Set<String> sets;
//map
private Map<String, String> maps;
//Properties
private Properties prop;
    
public Properties getProp() {
    return prop;
}

public void setProp(Properties prop) {
    Set<Object> keys = prop.keySet();
    for (Object obj : keys) {
        String key = (String)obj;
        System.out.println(key + " " +prop.getProperty(key));
    }
    this.prop = prop;
}

public Map<String, String> getMaps() {
    return maps;
}

public void setMaps(Map<String, String> maps) {
    Set<String> keys = maps.keySet();
    for (String key : keys) {
        System.out.println(key+" "+ maps.get(key));
    }
    this.maps = maps;
}

public Set<String> getSets() {
    return sets;
}

public void setSets(Set<String> sets) {
    for (String set : sets) {
        System.out.println(set);
    }
    this.sets = sets;
}

public List<UserDao> getUds() {
    return uds;
}

public void setUds(List<UserDao> uds) {
    for (UserDao ud : uds) {
        System.out.println(ud);
    }
    this.uds = uds;
}

public List<String> getList() {
    return list;
}

public void setList(List<String> list) {
    for (String lists : list) {
        System.out.println(lists);
    }
    this.list = list;
}

public int[] getArray2() {
    return array2;
}

public void setArray2(int[] array2) {
    for (int i : array2) {
        System.out.println(i);
    }
    this.array2 = array2;
}

public String[] getArray() {
    return array;
}

public void setArray(String[] array) {
    for (String arrays : array) {
        System.out.println(arrays);
    }
    this.array = array;
}

public int getFlag() {
    return flag;
}

public void setFlag(int flag) {
    System.out.println(flag);
    this.flag = flag;
}

public String getMsg() {
    return msg;
}

public void setMsg(String msg) {
    System.out.println(msg);
    this.msg = msg;
}

<!-- 属性注入用property标签  value值可以是String + 八种基本数据类型-->
<property name="msg" value="字符串注入"></property>
<property name="flag" value="6666"></property>
<property name="array">
    <array>
        <value>dilraba</value>
        <value>tom</value>
        <value>java</value>
    </array>
</property>
<property name="array2">
    <array>
        <value>111</value>
        <value>222</value>
        <value>333</value>
    </array>
</property>
<property name="list">
    <list>
        <value>fasdfas</value>
        <value>fdfafgf</value>
    </list>
</property>
<property name="uds">
    <list>
        <bean class="com.boom.dao.impl.UserDaoImpl"></bean>
    </list>
</property>
<property name="sets">
    <set>
        <value>sets1</value>
        <value>sets2</value>
    </set>
</property>
<property name="maps">
    <map>
        <entry key="key1">
            <value>value1</value>
        </entry>
                
        <entry key="key2">
            <value>value2</value>
        </entry>
    </map>
</property>
<property name="prop">
    <props>
        <prop key="prop1">prop11</prop>
        <prop key="prop2">prop22</prop>
    </props>
</property></bean>

属性注入小结（必须要有set方法）
　　属性注入通过property标签，注入String+八种基本数据类型用value标签，注入的是IOC容器自己的对象用ref，如果注入实体类对象，用bean标签缓存一下。
 Spring IOC注入方式用得最多的是(1)(2)种，通过Spring创建的对象默认是单例，如果需要创建多实例对象可以在<bean>标签后面添加一个属性：=

<bean name="..." class="..." scope="prototype">

 4、面向切面编程（AOP）
　　在面向对象编程（oop）思想中，我们将事物纵向抽成一个个的对象。而在面向切面编程中，我们将一个个的对象某些类似的方面横向抽成一个切面，对这个切面进行一些如权限控制、事物管理，记录日志等公用操作处理的过程就是面向切面编程的思想。AOP 底层是动态代理，如果是接口采用 JDK 动态代理，如果是类采用CGLIB 方式实现动态代理。
一些俗语的理解：
切面(aspect)：动态代理对象
连接点(joinpoint)：AOP可以是方法，属性，构造方法，都可以拦截。spring中仅支持对方法的拦截 
切点(pointcut)：动态代理拦截的目标，如动态代理的invoke
通知(advice)：前置，后置，环绕
Spring 切面可以应用五种类型的通知
1）方法的前置通知（before）
实现接口：MethodBeforeAdvice
功能：在目标方法(被代理的对象的方法)调用前,做什么
方法：void before(Method method, Object[] args, Object proxy)
主要应用于：记录日志 | 开启事务 | 其他功能处理
2）方法的后置通知（after  / after-returning）
after：在方法执行之后调用的通知，无论方法执行是否成功。
after-returning：仅当方法成功完成后执行的通知
3）方法异常通知（after-throwing）
实现接口：ThrowsAdvice
功能：在方法抛出异常退出时执行的通知
方法：void afterThrowing(RuntimeException e)
4）方法环绕通知（around）
实现接口：MethodInterceptor
方法：Object invoke(MethodInvocation arg0) throws Throwable
功能：在方法执行之前和之后调用的通知

目标(target)：被代理的对象
织入(weave)：目标和拦截对象捏合到一起的过程
springAOP：面向切面编程，是将纵向执行的流程。进行横向的切面，增加额外的功能。
切入的设计目标：使程序进行插拔式的开发，切的controller和service层之间。
代理模式：为真正处理业务的对象，提供附属功能的类型，称为代理。在不改变真正处理业务对象的代码前提下，为方法逻辑。增加新的功能的方式。
静态代理：代理对象专门为某一个对象或类型，提供针对性的服务支撑。功能全面强大，针对性强。缺陷是通用性降低。
动态代理：代理对象为某一类事务提供辅助功能支撑。通用性高，针对性不足。
静态代理代码实现
①定义接口：租赁接口，谁实现了这个接口，代表具有租赁能力，对外出租给第三方

package com.boom.staticproxy;
/**
 * 租赁接口，谁实现了这个接口，代表具有租赁能力，对外出租给第三方
 * @project_name proxy 
 * @class_name Rent
 * @author Dilraba
 */
public interface Rent {
    //定义一个房源
    public void rent();

}

②业主，房屋的持有者，实现了租赁接口

package com.boom.staticproxy;
/**
 * 业主, 房屋的持有者
 * @project_name proxy 
 * @class_name Host
 * @author Dilraba
 */
public class Host implements Rent{

    //出租的具体详情
    @Override
    public void rent() {
        System.out.println("签合同,交钱...");
    }
    

}

③代理对象，俗称二手房东等

package com.boom.staticproxy;
/**
 * 代理对象
 * @project_name proxy 
 * @class_name ProxyObject
 * @author Dilraba
 */
public class ProxyObject implements Rent {

    private Host host;
    
    public ProxyObject() {
    }
    public ProxyObject(Host host) {
        this.host = host;
    }
    
    @Override
    public void rent() {
        System.out.println("带顾客看房子....");
        host.rent();
        System.out.println("后期的一些乱七八糟事情。。。。");
    }
    
}

④模拟客户租房子

package com.boom.staticproxy;
/**
 * 模拟客户租房子
 * @project_name proxy 
 * @class_name StaticProxy
 * @author Dilraba
 */
public class TestProxy {
    public static void main(String[] args) {
        //创建客户
        Host t = new Host();
        //创建代理对象(二手房东)
        ProxyObject po = new ProxyObject(t);
        po.rent();
    }
}

静态代理代码实现
①定义接口

package com.boom.dynamicproxy;
/**
 * 租赁接口，谁实现了这个接口，代表具有租赁能力，对外出租给第三方
 * @project_name proxy 
 * @class_name Rent
 * @author Dilraba
 */
public interface Rent {
    //定义一个房源
    public void rent();

}

②实现接口

package com.boom.dynamicproxy;
/**
 * 业主, 房屋的持有者
 * @project_name proxy 
 * @class_name Host
 * @author Dilraba
 */
public class Host implements Rent{

    //出租的具体详情
    @Override
    public void rent() {
        System.out.println("签合同,交钱...");
    }
    

}

③动态代理：实现了InvocationHandler调用其invoke方法

package com.boom.dynamicproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * 代理对象
 * @project_name proxy 
 * @class_name DynamicProxy
 * @author Dilraba
 */
public class DynamicProxy implements InvocationHandler {

    private Object obj;
    public DynamicProxy() {
        
    }
    
    public DynamicProxy(Object obj) {
        super();
        this.obj = obj;
    }

    /**
     * @param proxy - 代理对象
     * @param method - 真实的方法, 就是要调用的最终方法. 业主出租访问的方法.
     * @param args - 真实方法要执行的时候,需要的参数.
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Advice...Before");
        System.out.println(proxy.getClass().getName());
        Object obj =  method.invoke(this.obj, args);
        System.out.println("Advice...After");
        return obj;
    }
    
}

④测试

package com.boom.dynamicproxy;

import java.lang.reflect.Proxy;

/**
 * 
 * @project_name proxy 
 * @class_name TestProxy
 * @author Dilraba
 */
public class TestProxy {
    public static void main(String[] args) {
        Host host = new Host();
        DynamicProxy dp = new DynamicProxy(host);
        Rent rent = (Rent)Proxy.newProxyInstance(host.getClass().getClassLoader(), host.getClass().getInterfaces(), dp);
        System.out.println(rent);//就是代理对象：com.boom.dynamicproxy.Host@6bc7c054
        rent.rent();
    }
}

5、Spring中AOP的开发四种方式(Spring中对于 AOP配置底层基于动态代理)
xml方式配置：在spring任意版本中都可以使用，缺：只能配置一个业务层，若业务层繁多做切面配置时候，配置信息繁琐，不便于管理。
①springAOP-xml.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- XSD约束的XML配置文件 -->
<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="com.boom.xml.service.impl.UserServiceImpl"></bean>
    <!-- 配置切面 -->
<bean id="myAOP" class="com.boom.xml.aop.MyAOP"></bean>

<bean id="userServieAOP" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="target">
        <ref bean="userService"/>
    </property>
    <property name="proxyInterfaces">
        <value>com.boom.xml.service.UserService</value>
    </property>
    <property name="interceptorNames">
        <list>
            <value>myAOP</value>
        </list>
    </property>
</bean>
</beans>

②接口和实现类

package com.boom.xml.service;

public interface UserService {
    
    void addUser();
}

package com.boom.xml.service.impl;

import com.boom.xml.service.UserService;

public class UserServiceImpl implements UserService {

    @Override
    public void addUser() {
        System.out.println("UserService...");
    }
    
}

③AOP

package com.boom.xml.aop;

import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.aop.framework.ProxyFactoryBean;

public class MyAOP implements MethodBeforeAdvice, AfterReturningAdvice, MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation arg0) throws Throwable {
        System.out.println("AOP联盟...before");
        Object obj = arg0.proceed();
        System.out.println("AOP联盟...after");
        return obj;
    }

    @Override
    public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {
        System.out.println("Spring...after");
        
    }

    @Override
    public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
        System.out.println("Spring...before");
    }

}

④测试类

package com.boom.xml.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.boom.xml.service.UserService;


public class Test {
    public static void main(String[] args) {
        //启动spring框架
        ApplicationContext ac = new ClassPathXmlApplicationContext("springAOP-xml.xml");
        UserService us = (UserService)ac.getBean("userServieAOP");
        us.addUser();
        
    }
}

⑤运行结果

spring aspect：在配置文件里配置<aop:config>，<aop:advisor>配置前置后置环绕等通知。
①springAOP-springaspect.xml 

<?xml version="1.0" encoding="UTF-8"?>
<!-- XSD约束的XML配置文件 -->
<!-- XSD约束的XML配置文件
    xmlns - xml namespace 命名空间, 默认命名空间.代表定义标签不需要写前缀.
    xmlns:xxx - 定义命名空间xxx. 使用标签为: <xxx:xxx>
 -->
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 目标 -->
<bean id="userService" class="com.boom.springaspect.service.impl.UserServiceImpl"></bean>
    <!-- 配置切面 -->
    <bean id="MyAfterAdvice" class="com.boom.springaspect.aop.MyAfterAdvice"></bean>
    <bean id="MyAroundAdvice" class="com.boom.springaspect.aop.MyAroundAdvice"></bean>
    <bean id="MyBeforeAdvice" class="com.boom.springaspect.aop.MyBeforeAdvice"></bean>
    <bean id="MyThrowsAdvice" class="com.boom.springaspect.aop.MyThrowsAdvice"></bean>
    
    <aop:config>
        <aop:pointcut expression="execution(* com.boom.springaspect.service.*.*(..))" id="mypointcut"/>
        <aop:advisor advice-ref="MyBeforeAdvice" pointcut-ref="mypointcut"/>
        <aop:advisor advice-ref="MyAfterAdvice" pointcut-ref="mypointcut"/>
        <aop:advisor advice-ref="MyAroundAdvice" pointcut-ref="mypointcut"/>
        <aop:advisor advice-ref="MyThrowsAdvice" pointcut-ref="mypointcut"/>
    </aop:config>
</beans>

②接口和实现类

package com.boom.springaspect.service;

public interface UserService {

    String addUser();
}

package com.boom.springaspect.service.impl;

import com.boom.springaspect.service.UserService;

public class UserServiceImpl implements UserService {

    public String addUser() {
        System.out.println("addUser..........");
        return "aaa";
    }

}

③AOP

package com.boom.springaspect.aop;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

public class MyBeforeAdvice implements MethodBeforeAdvice {

    @Override
    public void before(Method arg0, Object[] arg1, Object arg2) throws Throwable {
        System.out.println("Before.......");
    }

}

package com.boom.springaspect.aop;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;

public class MyAfterAdvice implements AfterReturningAdvice {

    @Override
    public void afterReturning(Object arg0, Method arg1, Object[] arg2, Object arg3) throws Throwable {
        System.out.println("After....");
    }

}

package com.boom.springaspect.aop;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class MyAroundAdvice implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation arg0) throws Throwable {
        System.out.println("AOP......Before");
        Object obj = arg0.proceed();
        System.out.println("AOP.......After");
        return obj;
    }

}

package com.boom.springaspect.aop;

import org.springframework.aop.ThrowsAdvice;

public class MyThrowsAdvice implements ThrowsAdvice {

    public void afterThrowing(RuntimeException e){
        System.out.println(e.getClass().getName());
    }
}

④测试

package com.boom.springaspect.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.boom.springaspect.service.UserService;


public class Test {

    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("springAOP-springaspect.xml");
        UserService us = (UserService)ac.getBean("userService");
        us.addUser();
    }

}

⑤运行结果

spring aspectj 方式：(spring 2.0以后引入)是专门做springAOP一个框架/技术，一开始并不是spring的，后来被spring收购了。AOP比xml更加通  用，简化。AspectJ不属于spring的标准技术，所以切面不需要实现spring中的通知接口。AspctJ的特点是通过方法+配置文件来定义aop
①springAOP-aspectj.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- XSD约束的XML配置文件 -->
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 目标 -->
    <bean id="userService" class="com.boom.aspectj.service.impl.UserServiceImpl"></bean>
    <!-- 配置切面 -->
    <bean id="myAOP" class="com.boom.aspectj.aop.MyAOPAspectj"></bean>
    <!-- 配置切点 -->
    <aop:config>
    <!-- 指定切面 -->
        <aop:aspect id="myaop" ref="myAOP">
        <!-- 配置通知行为 -->
            <aop:before method="doBefore" pointcut="execution( * com.boom.aspectj.service.*.*(..))"/>
            <aop:after-returning method="doAfter" returning="obj" pointcut="execution( * com.boom.aspectj.service.*.*(..))" />
            <aop:after-throwing method="doAfterThrowing" throwing="ex" pointcut="execution( * com.boom.aspectj.service.*.*(..))"/>
            <aop:around method="doAround" pointcut="execution( * com.boom.aspectj.service.*.*(..))"/>
        </aop:aspect>
    </aop:config>
</beans>

②接口和实现类

package com.boom.aspectj.service;

public interface UserService {
    
    void addUser();
}

package com.boom.aspectj.service.impl;

import com.boom.aspectj.service.UserService;

public class UserServiceImpl implements UserService {

    @Override
    public void addUser() {
        System.out.println("UserService...");
    }
    
}

③AOP

package com.boom.aspectj.aop;

import org.aspectj.lang.ProceedingJoinPoint;
/**
 * AspectJ不属于spring的标准技术，所以切面不需要实现spring中的通知接口
 * AspctJ的特点是通过方法+配置文件来定义aop
 * @project_name springAOP 
 * @class_name MyAOPAspectj
 * @author Dilraba
 */
public class MyAOPAspectj {
    public void doBefore(){
        System.out.println("Before...");
    }
    public void doAfter(Object obj){
        System.out.println("After...");
    }
    public void doAfterThrowing(RuntimeException ex){
        System.out.println(ex.getClass().getName());
        System.out.println("doAfterThrowing...");
    }
    public void doAround(ProceedingJoinPoint joinPoint) throws Throwable{
        System.out.println("doAround...before");
        joinPoint.proceed();
        System.out.println("doAround...after");
    }
}

④测试

package com.boom.aspectj.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.boom.aspectj.service.UserService;


public class Test {

    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("springAOP-aspectj.xml");
        UserService us = (UserService)ac.getBean("userService");
        us.addUser();
        
    }

}

⑤运行结果

spring annotation：需要使用Spring的注解和AspectJ的注解(注解就是)
①springAOP-annotation.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- XSD约束的XML配置文件 -->
<!-- XSD约束的XML配置文件
    xmlns - xml namespace 命名空间, 默认命名空间.代表定义标签不需要写前缀.
    xmlns:xxx - 定义命名空间xxx. 使用标签为: <xxx:xxx>
 -->
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    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/aop 
    http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
    http://www.springframework.org/schema/context  
    http://www.springframework.org/schema/context/spring-context.xsd">
    
    <context:component-scan base-package="com.boom.annotation"></context:component-scan>
    <!-- 开启注解 -->
    <context:annotation-config />
    <!-- 开启aspectj代理 -->
    <aop:aspectj-autoproxy />
</beans>

②接口和实现类

package com.boom.annotation.service;

public interface UserService {
    void addUser();
}

package com.boom.annotation.service.impl;

import org.springframework.stereotype.Service;

import com.boom.annotation.service.UserService;

@Service
public class UserServiceImpl implements UserService {

    @Override
    public void addUser() {
        System.out.println("addUser........");

    }

}

③AOP

package com.boom.annotation.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class MyAOP {
    
    @Pointcut("execution(* com.boom.annotation.service.*.*(..))")
    public void suibian(){
        
    }
    
    @Before("suibian()")
    public void doBefore(){
        System.out.println("doBefore......");
    }
    
    @After("suibian()")
    public void doAfter(){
        System.out.println("doAfter");
    }
    
    @Around("suibian()")
    public void around(ProceedingJoinPoint joinPoint)throws Throwable{
        System.out.println("around.....before");
        joinPoint.proceed();
        System.out.println("around.....after");
    }
}

④测试

package com.boom.annotation.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.boom.annotation.service.UserService;


public class Test {

    public static void main(String[] args) {
        //spring启动
        ApplicationContext ac = new ClassPathXmlApplicationContext("springAOP-annotation.xml");
        UserService us = (UserService)ac.getBean(UserService.class);
        us.addUser();
    }

}

⑤运行结果