优雅的Spring框架介绍

最新推荐文章于 2023-03-18 22:10:26 发布

likemebee

最新推荐文章于 2023-03-18 22:10:26 发布

阅读量1.5k

点赞数 2

分类专栏： spring

本文链接：https://blog.csdn.net/likemebee/article/details/78153106

版权

spring 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

什么是spring？我这里简单介绍一下：spring是一个一站式的解决框架，提供了开发JAVA应用程序时所需的全面的基础架构，所以你可以把注意力放到程序实现上。

spring的核心是控制反转（IoC）、依赖注入（DI）和面向切面（AOP）

spring的优点：

* 轻量级的容器框架，没有侵入性
* IoC更加容易组合对象之间的关系，通过面向接口进行编程，可以低耦合开发。
* 易于本地测试(Junit单元测试，不用部署服务器)
* AOP可以更加容易的进行功能扩展，遵循OCP开发原则。
* Spring默认对象的创建为单例的，我们不需要再使用单例的设计模式来开发单体类。
* Spring的集成很强大，另外可以对其他框架的配置进行一元化管理。
* Spring的声明式事务的方便使用

IoC： inversion of controller ，把创建对象的控制权利反转交给了spring，这一过程叫做控制反转（就是通过反射创建对象的过程）

首先要想用spring，第一步肯定就是导包咯。spring有 4 + 1 ： 4个核心（beans、core、context、expression） + 1个依赖（commons-loggins…jar）这里我用maven来加入这些依赖，没用maven的手动导入这些jar包就可以了！
maven的配置文件 pom.xml 如下：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.yida.spring</groupId>
  <artifactId>spring01</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>

    <dependencies>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>4.2.4.RELEASE</version>
</dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>4.2.4.RELEASE</version>
</dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>4.2.4.RELEASE</version>
</dependency>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-expression</artifactId>
    <version>4.2.4.RELEASE</version>
</dependency>

  <!-- https://mvnrepository.com/artifact/org.springframework/spring-web -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>4.2.4.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>

</dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>4.2.4.RELEASE</version>
</dependency>

  </dependencies>

  <build>  
    <plugins>  
        <plugin>  
            <groupId>org.apache.maven.plugins</groupId>  
            <artifactId>maven-compiler-plugin</artifactId>  
            <configuration>  
                <source>1.8</source>
                <target>1.8</target>  
            </configuration>  
        </plugin>  
    </plugins>  
</build>
</project>

入门案例：创建一个接口UserService

public interface UserService {
    void sayHello();
}

以及接口的实现类UserServiceImpl：

public class UserServiceImpl implements UserService{
    private String name;

    public String getName() {
        return name;
    }

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

    @Override
    public void sayHello() {
        System.out.println("hello spring"+name);
    }

}

applicationContext.xml配置如下：

<bean id="UserServiceImpl" class="com.yida.spring.demo01.UserServiceImpl">
    <property name="name" value="zhoujie"></property>
</bean>

测试用例：

@Test
    public void test01(){
        //获取spring容器
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserServiceImpl userservice = (UserServiceImpl) context.getBean("UserServiceImpl");
        userservice.sayHello();//结果：hello springzhoujie
    }

接下来测试通过静态工厂的方式来创建对象：
首先我们有一个生产静态工厂的方法 MyStaticFactory

public class MyStaticFactory {
    public static SayHelloFactoryClass getMyFactory(){
        return new SayHelloFactoryClass();
    }
}

具体的方法SayHelloFactoryClass

public class SayHelloFactoryClass {
    public void sayHello(){
        System.out.println("hello static myfactory class");
    }
}

applicationContext.xml配置如下：

<!-- 静态工厂创建对象 -->
<bean id="MyStaticFactory" class="com.yida.spring.demo02.MyStaticFactory" factory-method="getMyFactory"></bean>

测试用例：

/**
     * 测试静态工厂的方式创建对象
     */
    @Test
    public void test02(){
         ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
         SayHelloFactoryClass sayHello = (SayHelloFactoryClass) context.getBean("MyStaticFactory");
         sayHello.sayHello();//结果：hello static myfactory class
    }

实例工厂的方式来创建对象：
有一个实例工厂类MyInstanceFactory：

public class MyInstanceFactory {
    public MyInstanceFactoryClass getMyInstance(){
        return new MyInstanceFactoryClass();
    }
}

具体的方法为MyInstanceFactoryClass

public class MyInstanceFactoryClass {
    public void sayHello(){
        System.out.println("hello my instance factory");
    }
}

applicationContext.xml配置如下：

<!-- 实例工厂创建对象 -->
<bean id="MyInstanceFactory" class="com.yida.spring.demo02.MyInstanceFactory"></bean>
<bean id="MyInstanceFactoryClass" class="com.yida.spring.demo02.MyInstanceFactoryClass" factory-bean="MyInstanceFactory"

测试用例：

/**
     * 通过实例 工厂创建对象
     */
    @Test
    public void test03(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        MyInstanceFactoryClass myIns = (MyInstanceFactoryClass) context.getBean("MyInstanceFactoryClass");
        myIns.sayHello();//hello my instance factory
    }

spring对象的生命周期：
目标类BeanLife如下：

public class BeanLife {
    /**
     * 指定初始化方法
     */
    public void initMethod(){
        System.out.println("我是初始化方法，我在创建对象的时候就会被调用");
    }
    public void sayHello(){
        System.out.println("hello  bean  life  ");

    }
    /**
     * 指定销毁方法
     */
    public void destroyMehtod(){
        System.out.println("我是关闭方法，只有在容器关闭的时候，我才会被调用");
    }

}

applicationContext.xml配置如下：

<!-- spring对象的生命周期 -->
  <bean id="beanLife" class="cn.itcast.spring.demo3.BeanLife" init-method="initMethod" destroy-method="destroyMehtod"></bean>

测试用例：

/**
     * spring容器创建对象的生命周期
     */

    @Test
    public void getBeanLife() throws Exception {
        //获取容器
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        BeanLife bean = (BeanLife) context.getBean("beanLife");
        bean.sayHello();
        context.close();
    }

运行结果：
我是初始化方法，我在创建对象的时候就会被调用
hello bean life
我是关闭方法，只有在容器关闭的时候，我才会被调用

以上只是做了一个spring的基本用法介绍，spring的依赖注入这里就不做过多的介绍了，那么说一下spring与web的整合吧。通过以上介绍我们知道，再拿对象的时候通过spring容器我们已经不需要用一次就new一次了，这样大大节省了内存，那么问题来了，我们每次创建容器的时候都需要new，很麻烦，也很浪费内存。那么我们可不可以在我们的Tomcat服务器一启动的时候就创建我们的容器，然后就保证我们的容器不会被销毁呢？
办法是有的。我们的应用一启动就会去加载一个servletContext对象，直到我们的Tomcat停止为止！那么我们可以写一个监听器，来监听servletContext的启动（顺便提一下Javaweb的三大组件：servlet、filter、listener），servletContext一启动就马上启动spring的容器，spring的容器启动成功后就将spring容器丢到servletContext里面，以后每次用就直接从servletContext中获取即可，ok完成！注意这个过程已经有人帮我们写好了，我们不用自己写，虽然你自己写也是可以的。只需导入spring-web的包就可以了，前面一开始的时候我已经放在pom.xml里面了。然后在WEB-INF里的web.xml里配置监听器如下：

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

创建servlet测试：

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

        ServletContext servletContext = request.getServletContext();
        WebApplicationContext applicationContext = (WebApplicationContext) servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
        System.out.println(applicationContext);
        SayHelloFactoryClass bean = (SayHelloFactoryClass) applicationContext.getBean("MyStaticFactory");
        bean.sayHello();
        response.getWriter().append("Served at: ").append(request.getContextPath());
    }

这里调用的是静态工厂方法，spring与web的整合已经完成！

likemebee

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
1
评论
优雅的Spring框架介绍

什么是spring？我这里简单介绍一下：spring是一个一站式的解决框架，提供了开发JAVA应用程序时所需的全面的基础架构，所以你可以把注意力放到程序实现上。spring的核心是控制反转（IoC）、依赖注入（DI）和面向切面（AOP）spring的优点：* 轻量级的容器框架，没有侵入性* IoC更加容易组合对象之间的关系，通过面向接口进行编程，可以低耦合开发。* 易于本地测试(Junit单元测
复制链接

扫一扫