Spring 框架的理解

1、常见的几个之前不理解的名词解释

1.1 什么是POJO

/**
 * Plain Ordinary Java Object，即简单的java对象
 *
 * 需要有一些 private 的参数，以及针对参数的 setter 和 getter 方法来访问这些参数。
 *
 * 不作为一个业务对象，不继承或不实现任何其它Java框架的类或接口。
 * 一般在web应用程序中建立一个数据库的映射对象时，我们只能称它为POJO
 */
public class StudentPOJO {
    private String stuid;
    private String name;
    private int age;
    public String getStuid() {
        return stuid;
    }
    public void setStuid(String stuid) {
        this.stuid = stuid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

1.2 什么是JavaBean

JavaBean是Java中一种特殊的类，可以将多个对象封装到一个对象（bean）中。特点是可序列化，提供无参构造器，提供getter方法和setter方法访问对象的属性。

JavaBean呢就是需要实现一些规范，可以理解成POJO遵循一些规范就成了JavaBean

　提供一个默认的无参构造函数。
　需要被序列化并且实现了Serializable接口。
　可能有一系列可读写属性。
　可能有一系列的"getter"或"setter"方法。

public class StudentBean implements java.io.Serializable{
   private String firstName = null;
   private String lastName = null;
   private int age = 0;
   //无参构造函数
   public StudentBean() {
   }
   public String getFirstName(){
      return firstName;
   }
   public String getLastName(){
      return lastName;
   }
   public int getAge(){
      return age;
   }
   public void setFirstName(String firstName){
      this.firstName = firstName;
   }
   public void setLastName(String lastName){
      this.lastName = lastName;
   }
   public void setAge(int age) {
      this.age = age;
   }
}

1.3 什么是JavaSE和JavaEE

JavaSE：就是java基础

JavaEE：就是指Servlet开始后的常见的框架

2、什么是Spring

是个框架、是个容器、他更是整个spring 生态圈的基石。我们常见的Springmvc、Springboot、SpringCloud都是基于Spring。

3、Spring 的好处

我们如果不用Spring来开发一个web工程，单纯的使用servlet来开发的话，我们在控制层需要调用业务层的逻辑时需要手动的new对象才可以呢，如果使用Spring 和SpringMVC的话我们在web.xml中就不用配置那么多的servlet 标签了、同时控制层调用业务层时通过依赖注入就可以了。

/**
 * 处理登陆的请求
 */
public class LoginServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;
    private UserService userService = new UserServiceImpl();
   
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1. 获取请求参数数据
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        //2. 调用userService对象的login方法处理  -->返回一个boolean结果
        boolean success = userService.login(username, password);
        //3. 根据boolean结果转向到不同的页面
        if(success) {
            //重定向到login_success.html
            response.sendRedirect(request.getContextPath()+"/client/user/login_success.html");
        } else {
            //转发到login_error.html
            request.getRequestDispatcher("/client/user/login_error.html").forward(request, response);
        }
        
    }
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doGet(request, response);
    }

}

当然还有如下的好处

非侵入式:基于Spring 开发的应用中的对象可以不依赖Spring的API
依赖注入: DI --Dependency Injection, 是控制反转(IOC)思想的一个落地
面向切面编程:AOP
容器:Spring 是一个容器、因为它包含并管理应用对象的生命周期。
组件化:Spring 实现了使用简单的组件配置组合成一个复杂的应用。在Spring 中可以使用XML和Java 注解组合这些对象
一站式:在IOC和AOP的基础上可以整合各种企业应用的开源和优秀的第三方类库

4、Servlet 开发web工程的连接

这里可以体会到Spring的好处

https://gitee.com/gaoheqiang/boot-servlet

5、IOC

IOC的意思是Inversion Of Control (控制反转)

控制：控制资源的获取方式，容器可以控制对象的创建和销毁，控制组件的整个生命周期，这个是控制的含义
     主动式: 要什么资源都可以创建即可。之前没有用Servlet的时候，必须new 一个对象
        BookController{
           BookService bs = new BookService();
           AirPlane ap = new AirPlane(); //复杂对象的创建是比较庞大的工程如果手动的方式。
         
        }

     被动式：资源的获取都不是我们自己手动的创建，而不是交给一个容器来创建和设置

              BookController{
                   BookService bs;
                   public void test1(){
                       bs.checkout;//这里肯定报控制针。
                   }               
            }
        }

    容器：管理所有的组件（有功能的类）；假设BookController，BookService都受容器管理
    容器可以自动的探查出一个组件需要另一个组件。容器帮我们创建BookService对象，

反转的意思是：之前我们需要手动的new对象，后来我们不需要new对象了，spring容器帮我们new,

            由主动的new对象变成被动的接受对象，需要什么容器给我们创建。


DI 是IOC的具体实现，容器可以自动的探查出一个组件需要另一个组件，容器通过反射的方式给组件赋值（BookService）

6、bean 的生命周期

这里首先声明一下，Spring将管理的一个个的依赖对象称之为Bean,这从xml配置文件中也可以看出。

Spring IOC容器就好像一个生产产品的流水线上的机器，Spring创建出来的Bean就好像是流水线的终点生产出来的一个个精美绝伦的产品。既然是机器，总要先启动，Spring也不例外。因此Bean的一生从总体上来说可以分为两个阶段：

容器启动阶段
Bean实例化阶段

容器的启动阶段做了很多的预热工作，为后面Bean的实例化做好了充分的准备，我们首先看一下容器的启动阶段都做了哪些预热工作。

6.1 容器启动阶段

以下的代码是BeanFactoryPostProcessor 接口的实现来修改或者向容器中注入bean

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {

        //DefaultListableBeanFactory bdr = (DefaultListableBeanFactory)configurableListableBeanFactory;
        BeanDefinitionRegistry beanDefinitionRegistry = (DefaultListableBeanFactory)configurableListableBeanFactory;

        System.out.println("==============");

        GenericBeanDefinition gbd = new GenericBeanDefinition();
        gbd.setBeanClass(Parent.class);
        gbd.setScope(BeanDefinition.SCOPE_SINGLETON);
        gbd.setAutowireCandidate(true);
        beanDefinitionRegistry.registerBeanDefinition("parent",gbd);

    }
}

6.2 Bean实例化阶段

参考:https://mp.weixin.qq.com/s/NtT44auxmWRvZqzp2O3uUg

posted on 2022-01-09 22:07 与时具进&不忘初心阅读(231) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

唐僧喜欢小龙女

导航

公告