Day_04 Spring

最新推荐文章于 2024-09-15 09:47:04 发布

胖ۣۖ虎ۣۖ

最新推荐文章于 2024-09-15 09:47:04 发布

阅读量301

点赞数

文章标签： java Spring

本文链接：https://blog.csdn.net/lbw18/article/details/123937607

版权

文章目录

01-程序的耦合和解耦(掌握)

概述
- 耦合:完成一个功能时,模块与模块之间的关联性
- 内聚:完成一个功能时,独立完成的一个能力水平
- 高内聚低耦合
好处
- 代码复用率大大提高的，从而提高了实现功能的效率。换句话来说，我们需要再搭一个房子，我们可以直接使用现成的积木而非重新再构造一个房子。
- 提高程序的维护性。还是用搭房子的例子来说，当我们搭好的房子需要维护时，低耦合的理想状态可以做到撤掉一个积木，换上另一个接口匹配的积木后房子依旧是房子。但如果这些积木是高耦合的（可以理解为积木之间互相有着连线）那么在我们撤掉一块积木时，整个房子有可能面临着坍塌，这样就导致了我们的搭建效率大大降低。

02-三层结构的耦合性问题(掌握)

开发步骤
- ①定义controller代码
- ②定义service及其实现子类
- ③定义dao及其实现子类

①定义controller代码

public class UserController {

    public static void main(String[] args) throws Exception {
        UserService userService = new UserServiceImpl();
        userService.selectUserList();
    }

}

②定义service及其实现子类

public class UserServiceImpl implements UserService {



    public void selectUserList() throws Exception {
        System.out.println("UserServiceImpl selectUserList");
        UserDao userDao = new UserDaoImpl();
        userDao.selectUserList();
    }
}

③定义dao及其实现子类

public class UserDaoImpl implements UserDao {
    public void selectUserList() throws Exception {
        System.out.println("UserDaoImpl selectUserList");
    }
}

存在问题
- ①在UserController类中,如果要使用UserService对象,是调用了UserServiceImpl构造器,如果UserServiceImpl构造器发生改变,那么UserController类的调用也要跟随改变,这就说明,UserController和UserService之间存在耦合;
- ②在UserController类中,如果要使用UserService对象,是通过new方式来创建对象,那么就需要使用import关键字来导包,否则编译报错.
解决方案
- ①使用工厂模式
- ②使用反射创建对象

03-解耦方案使用工厂模式(掌握)

代码实现

public class MyApplicationContext {

    public Object getBean(String beanName){
        if (beanName.equals("userService")) {
            return new UserServiceImpl();
        } else if (beanName.equals("userDao")) {
            return new UserDaoImpl();
        }

        return null;
    }

}

public class UserController {

    public static void main(String[] args) throws Exception {
        UserService userService = (UserService) new MyApplicationContext().getBean("userService");
        userService.selectUserList();
    }

}

public class UserServiceImpl implements UserService {

    public void selectUserList() throws Exception {
        System.out.println("UserServiceImpl selectUserList");
        UserDao userDao = (UserDao) new MyApplicationContext().getBean("userDao");
        userDao.selectUserList();
    }
}

public class UserDaoImpl implements UserDao {
    public void selectUserList() throws Exception {
        System.out.println("UserDaoImpl selectUserList");
    }
}

04-解耦方案使用反射(掌握)

代码实现

public class MyApplicationContext {


    /**
     * 使用反射动态创建对象
     * @param className : 全限定类名
     * @return
     */
    public Object getBean(String className){
        try {
            return Class.forName(className).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

}

public class UserController {

    public static void main(String[] args) throws Exception {
        UserService userService = (UserService) new MyApplicationContext().getBean("com.atguigu.service.impl.UserServiceImpl");
        userService.selectUserList();
    }

}

public class UserServiceImpl implements UserService {

    public void selectUserList() throws Exception {
        System.out.println("UserServiceImpl selectUserList");
        UserDao userDao = (UserDao) new MyApplicationContext().getBean("com.panghu.dao.impl.UserDaoImpl");
        userDao.selectUserList();
    }
}

public class UserDaoImpl implements UserDao {
    public void selectUserList() throws Exception {
        System.out.println("UserDaoImpl selectUserList");
    }
}

存在问题
- 存在className全限定类名的字符串的硬编码

05-解耦方案使用配置文件(掌握)

代码实现

public class MyApplicationContext {


    private Map<String, Object> map = new HashMap<String, Object>();

    public MyApplicationContext() {
        parseXML();
    }

    private void parseXML() {
        SAXReader saxReader = new SAXReader();
        try {
            InputStream inputStream = MyApplicationContext.class.getClassLoader().getResourceAsStream("beans.xml");
            Document document = saxReader.read(inputStream);
            Element rootElement = document.getRootElement();
            List<Element> beanElements = rootElement.elements("bean");
            for (Element beanElement : beanElements) {
                String id = beanElement.attributeValue("id");
                String className = beanElement.attributeValue("class");
                Object instance = Class.forName(className).newInstance();
                map.put(id, instance);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }


    }

    /**
     * 获取对象
     *
     * @param beanId : 对象ID
     * @return
     */
    public Object getBean(String beanId) {
        return map.get(beanId);
    }

}

public class UserController {

    public static void main(String[] args) throws Exception {

        UserService userService = (UserService) new MyApplicationContext().getBean("userService");
        userService.selectUserList();
    }

}

public class UserServiceImpl implements UserService {

    public void selectUserList() throws Exception {

        System.out.println("UserServiceImpl selectUserList");
        UserDao userDao = (UserDao) new MyApplicationContext().getBean("userDao");
        userDao.selectUserList();
    }
}

public class UserDaoImpl implements UserDao {
    public void selectUserList() throws Exception {
        System.out.println("UserDaoImpl selectUserList");
    }
}

06-Spring概述(掌握)

概述
- Spring是分层的 Java SE/EE应用轻量级开源框架，以 IOC和 AOP为内核。
- 提供了视图层SpringMVC和持久层Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的JavaEE企业应用开源框架
官网
- Spring | Home
优势
- 方便解耦，简化开发
- AOP 编程的支持
- 声明式事务的支持
- 方便程序的测试
结构

07-Spring入门案例(掌握)

开发步骤
- ①引入依赖
- ②编写spring核心配置文件
- ③代码测试

①引入依赖

<properties>
    <spring.version>5.3.16</spring.version>
</properties>

<dependencies>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-expression</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jcl</artifactId>
        <version>${spring.version}</version>
    </dependency>


</dependencies>

②编写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="user1" class="com.panghu.pojo.User">

    </bean>

    <bean id="user2" class="com.panghu.pojo.User">

    </bean>

</beans>

③代码测试

@Test
public void test1(){
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
    Object user1 = applicationContext.getBean("user1");
    System.out.println("user1 = " + user1);

    Object user2 = applicationContext.getBean("user2");
    System.out.println("user2 = " + user2);
}

08-IOC控制反转(掌握)

概述
- IOC : inversion of controller ,控制反转
- 以前,资源的控制权在Java程序手上,耦合度较高;
- 现在,资源的控制权在Spring容器手上,就降低耦合度.

09-Spring使用构造器IOC对象(掌握)

概述
- ""使用实体类的无参构造器来创建对象,并将对象存放到Spring容器.
注意事项
- 实体类必须要提供对应的无参构造器,否则报错.

10-Spring使用静态工厂IOC对象(了解)

代码实现

public class StaticUserFactory {

    public static User getUser(){
        return new User(1,"静态","static");
    }

}

<bean id="user3" factory-method="getUser" class="com.panghu.factory.StaticUserFactory">

</bean>

11-Spring使用动态工厂IOC对象(了解)

代码实现

public class DynamicUserFactory {

    public User getUser(){
        return new User(2,"动态","dynamic");
    }
}

<bean id="user4" factory-method="getUser" factory-bean="dynamicUserFactory"></bean>

<bean id="dynamicUserFactory" class="com.panghu.factory.DynamicUserFactory"></bean>

12-FactoryBean机制(掌握)

概述
- FactoryBean是Spring提供的一种整合第三方框架的常用机制。和普通的bean不同，配置一个 FactoryBean类型的bean，在获取bean的时候得到的并不是class属性中配置的这个类的对象，而是 getObject()方法的返回值。通过这种机制，Spring可以帮我们把复杂组件创建的详细过程和繁琐细节都屏蔽起来，只把最简洁的使用界面展示给我们。

源码

public interface FactoryBean<T> {

   String OBJECT_TYPE_ATTRIBUTE = "factoryBeanObjectType";


   @Nullable
   T getObject() throws Exception;

   @Nullable
   Class<?> getObjectType();


   default boolean isSingleton() {
      return true;
   }

}

代码实现

public class UserFactoryBean implements FactoryBean<User> {
    public User getObject() throws Exception {
        return new User(3,"factorybean机制","factorybean");
    }

    public Class<?> getObjectType() {
        return User.class;
    }

    public boolean isSingleton() {
        return true;
    }
}

<bean id="user5" class="com.panghu.pojo.UserFactoryBean"></bean>

13-bean标签属性(掌握)

语法

<bean 
      id="" //对象唯一标识
      class="" //对象的全限定类名
      factory-bean="" //工厂对象
      factory-method="" //工厂方法
      init-method="" //设置监听对象初始化的方法
      destroy-method="" //设置监听对象销毁的方法
      name="" //对象别名
      scope="" //对象生命周期
      ></bean>

代码实现

<bean id="user6" name="myUser6" class="com.panghu.pojo.User"></bean>

14-Spring团队开发(掌握)

概述
- 开发中,一个项目是有多个模块的,就意味着有多个spring配置文件,如何整合多个spring配置文件了.

代码实现1

@Test
public void test6() {
    ClassPathXmlApplicationContext applicationContext =
            new ClassPathXmlApplicationContext(
                    "spring1.xml",
                    "spring2.xml",
                    "spring3.xml");
    Object user1 = applicationContext.getBean("user1");
    System.out.println("user1 = " + user1);
    Object user2 = applicationContext.getBean("user2");
    System.out.println("user2 = " + user2);
}

代码实现2

<?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="user1" class="com.panghu.pojo.User"></bean>

    <import resource="spring2.xml"></import>
    <import resource="spring3.xml"></import>
</beans>

注意事项
- 后加载的spring配置会覆盖之前加载的spring配置.

15-Spring引入logback(掌握)

概述
- ①System.out.println是线程安全的,效率非常低;
- ②System.out.println无法做到在开发阶段打印,在生产阶段就关闭.
日志框架
- jul,log4J,log4j2,logback
日志门面
- jcl,sfl4j
日志等级
- error,warn,info,debug,trace
- 日志等级=debug,那么error,warn,info,debug都会打印
开发步骤
- ①引入相关依赖
  - slf4j , logback
- ②定义logback.xml
- ③代码测试

①引入相关依赖

<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>${slf4j.version}</version>
</dependency>
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>${logback.version}</version>
</dependency>

②定义logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="true">
    <!-- 指定日志输出的位置 -->
    <appender name="STDOUT"
              class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <!-- 日志输出的格式 -->
            <!-- 按照顺序分别是：时间、日志级别、线程名称、打印日志的类、日志主体内容、换行 -->
            <pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger] [%msg]%n</pattern>
        </encoder>
    </appender>

    <!-- 设置全局日志级别。日志级别按顺序分别是：DEBUG、INFO、WARN、ERROR -->
    <!-- 指定任何一个日志级别都只打印当前级别和后面级别的日志。 -->
    <root level="debug">
        <!-- 指定打印日志的appender，这里通过“STDOUT”引用了前面配置的appender -->
        <appender-ref ref="STDOUT"/>
    </root>

    <logger name="java.sql">
        <level value="debug"/>
    </logger>

    <logger name="org.apache.ibatis">
        <level value="info"/>
    </logger>

</configuration>

③代码测试

public class LogTest {


    Logger logger = LoggerFactory.getLogger(LogTest.class);


    @Test
    public void testLog(){
        logger.error("testLog error");
        logger.warn("testLog warn");
        logger.info("testLog info");
        logger.debug("testLog debug");
        logger.trace("testLog trace");
    }


}

16-根据类型获取bean场景一(掌握)

需求
- ①IOC容器中同类型的bean只有一个
- ②IOC容器中同类型的bean有多个
总结
- ①IOC容器中同类型的bean只有一个
  - 可以正常获取
- ②IOC容器中同类型的bean有多个
  - 不能正常获取,会报错"NoUniqueBeanDefinitionException"

17-根据类型获取bean场景二(掌握)

需求
- 有一个接口,该接口有一个实现子类,将实现子类的对象放入到IOC容器
- ①根据接口类型获取bean
- ②根据实现子类类型获取bean
总结
- ①根据接口类型获取bean
  - 可以正常获取
- ②根据实现子类类型获取bean
  - 可以正常获取

18-根据类型获取bean场景三(掌握)

需求
- 有一个接口,该接口有多个实现子类,将多个实现子类的对象放入到IOC容器
- ①根据接口类型获取bean
- ②根据实现子类类型获取bean
总结
- ①根据接口类型获取bean
  - 不能正常获取,会报错"NoUniqueBeanDefinitionException"
- ②根据实现子类类型获取bean
  - 可以正常获取

19-bean作用域(掌握)

作用域
- singleton : 单例,默认值
- prototype : 多例
- request : web项目,请求结束,bean对象就销毁
- session : web项目,会话结束,bean对象就销毁
singleton
- 对象创建:Spring容器创建,对象就创建
- 对象销毁:Spring容器关闭,对象就销毁
prototype
- 对象创建:使用对象,就创建对象
- 对象销毁:由JVM的垃圾回收机制来销毁

代码实现

public class Student {

    private String stuName;
    private Integer age;

    public void init(){
        System.out.println("Student初始化");
    }

    public void destroy(){
        System.out.println("Student销毁");

    }

}

<bean id="stu" class="com.panghu.pojo.Student" scope="prototype" init-method="init" destroy-method="destroy"></bean>

@Test
public void test4(){
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring2.xml");
    applicationContext.getBean("stu");
    applicationContext.getBean("stu");
    applicationContext.getBean("stu");
    applicationContext.close();
}

20-bean生命周期(掌握)

生命周期

21-BeanPostProcessor处理器(掌握)

概述
- 可以用于在bean对象初始化前后做一些预处理
开发步骤
- ①自定义类实现BeanPostProcessor接口
- ②StudentBeanPostProcessor对象存放到IOC容器

代码实现

public class StudentBeanPostProcessor implements BeanPostProcessor {

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

        if (bean instanceof Student) {
            System.out.println("Student BeforeInitialization");
        }
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof Student) {
            System.out.println("Student AfterInitialization");
        }
        return bean;
    }
}

<bean class="com.atguigu.processor.StudentBeanPostProcessor"></bean>

22-bean生命周期练习(掌握)

需求
- 自定义连接池

代码实现

public class MyDataSource {

    private String driverClassName;
    private String url;
    private String user;
    private String password;
    private Integer initPoolSize;//初始连接数

    private LinkedList<Connection> list = new LinkedList<Connection>();

    public MyDataSource() {
        System.out.println("MyDataSource实例化");
    }

    /**
     * 初始化
     * @throws SQLException
     */
    public void init() throws SQLException, ClassNotFoundException {
        System.out.println("MyDataSource初始化");

        Class.forName(driverClassName);

        for (Integer i = 0; i < initPoolSize; i++) {
            Connection connection = DriverManager.getConnection(url, user, password);
            list.add(connection);
        }
    }

    public Connection getConnection() {
        return list.removeFirst();
    }


    /**
     * 销毁
     */
    public void destroy() {
        System.out.println("MyDataSource销毁");
        list.clear();
    }


}

public class MyDataSourceBeanPostProcessor implements BeanPostProcessor {

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof MyDataSource) {//在MyDataSource初始化之前,将initPoolSize设置为50
            System.out.println("postProcessBeforeInitialization");
            MyDataSource dataSource = (MyDataSource) bean;
            dataSource.setInitPoolSize(50);
        }
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof MyDataSource) {//在MyDataSource初始化之后,获取initPoolSize
            System.out.println("postProcessAfterInitialization");
            MyDataSource dataSource = (MyDataSource) bean;
            System.out.println("initPoolSize=" + dataSource.getInitPoolSize());
        }
        return bean;
    }
}

<bean id="dataSource" class="com.atguigu.datasource.MyDataSource" init-method="init" destroy-method="destroy">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/mydb1"></property>
    <property name="user" value="root"></property>
    <property name="password" value="root"></property>
    <property name="initPoolSize" value="10"></property>

</bean>

<bean class="com.panghu.processor.MyDataSourceBeanPostProcessor"></bean>

23-依赖注入DI(掌握)

概述
- DI : dependency injection , 依赖注入
- IOC是将资源存放到Spring容器,DI是将资源从Spring容器取出并放入到Java程序使用
常用方式
- 构造器注入
- set方法注入
- 注解注入

24-构造器注入(掌握)

概述
- 顾名思义，就是使用类中的构造函数，给成员变量(简单类型、javaBean)赋值。注意，赋值的操作不是我们自己做的，而是通过配置的方式，让spring框架来为我们注入。

代码实现

<!--24-构造器注入-->
<!--①简单类型-->
<bean id="user1" class="com.panghu.pojo.User">
    <constructor-arg name="userId" value="1"></constructor-arg>
    <constructor-arg name="userName" value="张三"></constructor-arg>
    <constructor-arg name="userPwd" value="123456"></constructor-arg>
</bean>

<!--②实体类型-->
<bean id="user2" class="com.panghu.pojo.User">
    <constructor-arg name="userId" value="2"></constructor-arg>
    <constructor-arg name="userName" value="李四"></constructor-arg>
    <constructor-arg name="userPwd" value="123456"></constructor-arg>
    <constructor-arg name="order" ref="order"></constructor-arg>
</bean>

<bean id="order" class="com.panghu.pojo.Order">
    <constructor-arg name="orderName" value="java"></constructor-arg>
    <constructor-arg name="orderState" value="好评"></constructor-arg>
</bean>

注意事项
- 需要提供对应的构造器.

25-set方法注入(掌握)

概述
- 顾名思义，就是在类中提供需要注入成员的set方法给成员变量(简单类型、javaBean)赋值。注意，赋值的操作不是我们自己做的，而是通过配置的方式，让spring框架来为我们注入。

代码实现

<!--25-set方法注入-->
<!--①简单类型-->
<bean id="user3" class="com.panghu.pojo.User">
    <property name="userId" value="3"></property>
    <property name="userName" value="张三"></property>
    <property name="userPwd" value="123456"></property>
</bean>

<!--②实体类型-->
<bean id="user4" class="com.panghu.pojo.User">
    <property name="userId" value="4"></property>
    <property name="userName" value="李四"></property>
    <property name="userPwd" value="123456"></property>
    <property name="order" ref="order"></property>
</bean>

26-容器注入(掌握)

代码实现

<bean id="bean01" class="com.panghu.pojo.Bean01">
    <property name="myStrs">
        <array>
            <value>a</value>
            <value>b</value>
            <value>c</value>
        </array>
    </property>
    <property name="myList">
        <list>
            <value>a</value>
            <value>b</value>
            <value>c</value>
        </list>
    </property>
    <property name="mySet">
        <set>
            <value>a</value>
            <value>b</value>
            <value>c</value>
        </set>
    </property>
    <property name="myMap">
        <map>
            <entry key="1" value="a"></entry>
            <entry key="2" value="b"></entry>
            <entry key="3" value="c"></entry>
        </map>
    </property>
    <property name="myProps">
        <props>
            <prop key="1">a</prop>
            <prop key="2">b</prop>
            <prop key="3">c</prop>
        </props>
    </property>

</bean>

27-p命名空间引入(了解)

概述
- 简化依赖注入操作

代码实现

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:p="http://www.springframework.org/schema/p"
       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="user5"
          class="com.panghu.pojo.User"
          p:userId="5"
          p:userName="张三"
          p:userPwd="12345"
          p:order-ref="order">
    </bean>
</beans>

28-ApplicationContext继承结构(了解)

继承结构
- FileSystemXmlApplicationContext : 根据系统xml文件加载Spring容器
- ClassPathXmlApplicationContext : 根据类路径xml文件加载Spring容器
- AnnotationConfigApplicationContext : 根据注解配置加载Spring容器

29-BeanFactory和ApplicationContext的区别(了解)

BeanFactory
- 提供了最简单的容器的功能，只提供了实例化对象和获取对象的功能；
- 容器启动的时候不会实例化bean，从容器中获取bean的时候才会去实例化；
ApplicationContext
- 提供了更高级的容器的功能 …
- 容器启动的时候就把所有的Bean全部实例化了。它还可以为bean配置lazy-init=true来让Bean延迟实例化

代码实现

public void test(){
    BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring4.xml"));
    Object user1 = beanFactory.getBean("user1");
    Object user2 = beanFactory.getBean("user1");
    System.out.println(user1 == user2);

}

30-ApplicationContext的三个实现类(掌握)

三个实现类
- FileSystemXmlApplicationContext : 根据系统xml文件加载Spring容器
- ClassPathXmlApplicationContext : 根据类路径xml文件加载Spring容器
- AnnotationConfigApplicationContext : 根据注解配置加载Spring容器

FileSystemXmlApplicationContext

@Test
public void test2(){
    FileSystemXmlApplicationContext applicationContext =
            new FileSystemXmlApplicationContext("C:\\Users\\qiuzhiwei\\Desktop\\spring4.xml");
    Object user1 = applicationContext.getBean("user1");
    Object user2 = applicationContext.getBean("user1");
    System.out.println(user1 == user2);
}

AnnotationConfigApplicationContext

@Configuration
public class MySpringConfiguration {

    @Bean("user1")
    public User getUser(){
        return new User(1,"刘吕港","12345");
    }

}

@Test
public void test3(){
    AnnotationConfigApplicationContext applicationContext =
            new AnnotationConfigApplicationContext(MySpringConfiguration.class);
    User user = (User) applicationContext.getBean("user1");
    System.out.println("user = " + user);
}