spring春天入门


备注

Spring Framework是一个开源的应用程序框架和Java平台的控件容器的反转。

版本

发布日期
版本4.3.x 2016年6月10日
4.2.x版 2015年7月31日
4.1.x版 2014年9月14日
4.0.x版 二零一三年十二月十二日
3.2.x中 二零一二年十二月一十三日
3.1.X 2011-12-13
3.0.x的 2009-12-17
2.5.X 2007-12-25
2.0.x版本 2006-10-04
1.2.x版本 2005-05-13
1.1.x版本 2004-09-05
1.0.x的 2003-03-24

设置(XML配置)

创建Hello Spring的步骤:

  1. 调查Spring Boot以查看是否更适合您的需求。
  2. 使用正确的依赖项设置项目。建议您使用MavenGradle
  3. 创建一个POJO类,例如Employee.java
  4. 创建一个XML文件,您可以在其中定义类和变量。例如beans.xml
  5. 创建您的主类,例如Customer.java
  6. 包含spring-beans (及其传递依赖项!)作为依赖项。

Employee.java

package com.test;

public class Employee {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void displayName() {
        System.out.println(name);
    }
}
 

beans.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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
        
    <bean id="employee" class="com.test.Employee">
        <property name="name" value="test spring"></property>
    </bean>

</beans>
 

Customer.java

package com.test;

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

public class Customer {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

      Employee obj = (Employee) context.getBean("employee");
      obj.displayName();
   }
}
 

通过示例展示Core Spring功能

描述

这是一个独立的运行示例,包括/ showcasing:所需的最小依赖项 ,Java 配置 ,注释和Java配置的Bean声明 ,构造函数和属性的依赖注入 ,以及Pre / Post挂钩。

依赖

类路径中需要这些依赖项:

  1. 弹簧核心
  2. 春天上下文
  3. 弹簧豆
  4. 春天的AOP
  5. 弹簧表达
  6. 共享记录

主类

从最后开始,这是我们的Main类,它充当main() 方法的占位符,它通过指向Configuration类来初始化Application Context并加载展示特定功能所需的所有各种bean。

package com.stackoverflow.documentation;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;



public class Main {

    public static void main(String[] args) {

        //initializing the Application Context once per application.
        ApplicationContext applicationContext = 
                new AnnotationConfigApplicationContext(AppConfig.class);

        //bean registered by annotation
        BeanDeclaredByAnnotation beanDeclaredByAnnotation = 
                applicationContext.getBean(BeanDeclaredByAnnotation.class);
        beanDeclaredByAnnotation.sayHello();

        //bean registered by Java configuration file
        BeanDeclaredInAppConfig beanDeclaredInAppConfig = 
                applicationContext.getBean(BeanDeclaredInAppConfig.class);
        beanDeclaredInAppConfig.sayHello();

        //showcasing constructor injection
        BeanConstructorInjection beanConstructorInjection = 
                applicationContext.getBean(BeanConstructorInjection.class);
        beanConstructorInjection.sayHello();

        //showcasing property injection
        BeanPropertyInjection beanPropertyInjection = 
                applicationContext.getBean(BeanPropertyInjection.class);
        beanPropertyInjection.sayHello();

        //showcasing PreConstruct / PostDestroy hooks
        BeanPostConstructPreDestroy beanPostConstructPreDestroy = 
                applicationContext.getBean(BeanPostConstructPreDestroy.class);
        beanPostConstructPreDestroy.sayHello();
    }
}
 

应用配置文件

配置类由@Configuration 注释,并在初始化的应用程序上下文中用作参数。配置类的类级别的@ComponentScan 注释指向要扫描的Bean和使用注释注册的依赖项的包。最后, @Bean 注释在配置类中用作bean定义。

package com.stackoverflow.documentation;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.stackoverflow.documentation")
public class AppConfig {

    @Bean
    public BeanDeclaredInAppConfig beanDeclaredInAppConfig() {
        return new BeanDeclaredInAppConfig();
    }
}
 

注释的Bean声明

@Component 注释用于将POJO划分为可在组件扫描期间注册的Spring bean。

@Component
public class BeanDeclaredByAnnotation {

    public void sayHello() {
        System.out.println("Hello, World from BeanDeclaredByAnnotation !");
    }
}
 

应用程序配置的Bean声明

请注意,我们不需要注释或以其他方式标记我们的POJO,因为bean声明/定义发生在Application Configuration类文件中。

public class BeanDeclaredInAppConfig {

    public void sayHello() {
        System.out.println("Hello, World from BeanDeclaredInAppConfig !");
    }
}
 

构造函数注入

请注意,@ @Autowired 注释是在构造函数级别设置的。另请注意,除非通过名称明确定义,否则将根据 bean 的类型 (在此实例中为BeanToBeInjected )进行默认自动BeanToBeInjected

package com.stackoverflow.documentation;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class BeanConstructorInjection {

    private BeanToBeInjected dependency;

    @Autowired
    public BeanConstructorInjection(BeanToBeInjected dependency) {
        this.dependency = dependency;
    }

    public void sayHello() {
        System.out.print("Hello, World from BeanConstructorInjection with dependency: ");
        dependency.sayHello();
    }
}
 

物业注入

请注意,@ @Autowired 注释划分了名称遵循JavaBeans标准的setter方法。

package com.stackoverflow.documentation;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class BeanPropertyInjection {

    private BeanToBeInjected dependency;

    @Autowired
    public void setBeanToBeInjected(BeanToBeInjected beanToBeInjected) {
        this.dependency = beanToBeInjected;
    }

    public void sayHello() {
        System.out.println("Hello, World from BeanPropertyInjection !");
    }
}
 

PostConstruct / PreDestroy挂钩

我们可以通过@PostConstruct@PreDestroy 钩子拦截Bean的初始化和销毁​​。

package com.stackoverflow.documentation;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class BeanPostConstructPreDestroy {

    @PostConstruct
    public void pre() {
        System.out.println("BeanPostConstructPreDestroy - PostConstruct");
    }

    public void sayHello() {
        System.out.println(" Hello World, BeanPostConstructPreDestroy !");
    }

    @PreDestroy
    public void post() {
        System.out.println("BeanPostConstructPreDestroy - PreDestroy");
    }
}
 

什么是Spring Framework,我们为什么要这样做呢?

Spring是一个框架,它提供了一堆类,通过使用它我们不需要在代码中编写样板函数,因此Spring在J2ee上提供了一个抽象层。


例如,简单JDBC应用程序程序员负责

  1. 加载驱动程序类
  2. 创建连接
  3. 创建语句对象
  4. 处理异常
  5. 创建查询
  6. 执行查询
  7. 关闭连接

这被视为样板代码,因为每个程序员都编写相同的代码。因此,为简单起见,框架负责样板逻辑,程序员必须只编写业务逻辑。因此,通过使用Spring框架,我们可以使用最少的代码行快速开发项目,没有任何错误,开发成本和时间也减少了。

所以为什么选择Spring作为struts就在那里

Strut是一个框架,它只为web方面提供解决方案,struts本质上是侵入性的。 Spring比struts有很多功能所以我们必须选择Spring。

  1. Spring本质上是非侵入性的:这意味着您不需要扩展任何类或实现任何类的接口。
  2. Spring是多功能的 :这意味着它可以与项目中的任何现有技术集成。
  3. Spring提供端到端的项目开发:这意味着我们可以开发所有模块,如业务层,持久层。
  4. Spring 重量轻 :这意味着如果你想在特定的模块上工作,你不需要学习完整的弹簧,只学习那个特定的模块(例如Spring Jdbc,Spring DAO)
  5. Spring支持依赖注入
  6. Spring支持多项目开发,例如:核心java应用程序,Web应用程序,分布式应用程序,企业应用程序
  7. Spring支持面向方面编程以满足横切关注。

最后我们可以说Spring是Struts的替代品。但Spring并不是J2EE API的替代品,因为Spring提供的类在内部使用J2EE API类。 Spring是一个庞大的框架,因此它分为几个模块。除了Spring Core之外,没有模块依赖于另一个模块。一些重要的模块是

  1. 春天核心
  2. Spring JDBC
  3. 春天AOP
  4. 春季交易
  5. 春天ORM
  6. Spring MVC