spring介绍

一.spring概述

1.简单介绍

Spring 是一个分层的 轻量级开源框架.Spring 的核心是控制反转（IOC）和面向切面(AOP).她可以说是给开发java的程序员带来了春天.

2.为什么使用spring

1. 方便解耦，简化开发
2. Spring 就是一个大工厂，可以将所有对象创建和依赖关系维护，交给 Spring 管理
3. AOP 编程的支持，Spring 提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
4. 声明式事务的支持只需要通过配置就可以完成对事务的管理，
5. 而无需手动编程方便程序的测试，Spring 对 Junit4 支持，可以通过注解方便的测试 Spring 程序
6. 方便集成各种优秀框架，Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz 等）的直接支持
7. 降低 JavaEE API 的使用难度，Spring 对 JavaEE 开发中非常难用的一些 API（JDBC、JavaMail、远程调用等），都提供了封装，使这些 API 应用难度大大降低

3.spring的架构

二.创建简单的spring项目

1.创建一个maven项目

如下:
这里我创建的是一个module,project也是一样的创建方法

2.导入依赖

主要是spring四个核心包,beans,core,context.spel(spring表达式的简写)

<?xml version="1.0" encoding="UTF-8"?>
<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.tledu</groupId>
    <artifactId>spring-stu</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>spring01</module>
    </modules>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <spring.version>4.2.5.RELEASE</spring.version>
    </properties>

    <dependencies>
      	<!--spring的四大核心依赖-->
        <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-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--日志相关-->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <!--测试相关-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
        <!--hutool-->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.7.7</version>
        </dependency>

    </dependencies>

</project>

3.创建spring的配置文件 applicationContext.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.xsd">
    <bean name="userDao" class="com.tledu.spring01.dao.impl.UserDaoImpl"></bean>
</beans>

4.创建包结构并写对应的代码

如下:

对应代码
IUserDaoImpl

package com.tledu.spring01.dao;

import com.tledu.spring01.model.User;

/**
 * 用户dao
 */
public interface IUserDao {
    User findUserById(Integer id);
}

UserDaoImpl

package com.tledu.spring01.dao.impl;

import com.tledu.spring01.model.User;
import com.tledu.spring01.dao.IUserDao;

/**
 * userDao实现类
 * @author Antg
 * @date 2021/8/511:01
 */
public class UserDaoImpl implements IUserDao {
    @Override
    public User findUserById(Integer id) {
        //这里输出一句话来表示该方法执行了
        System.out.println("执行了findUserById方法");
        return null;
    }
}

User

package com.tledu.spring01.model;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

/**
 * @author Antg
 * @date 2021/8/510:58
 */
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Integer id;
    private String username;
    private String password;
    private String nickname;
    private Integer age;
    private Date birthday;
}

IUserService

package com.tledu.spring01.service;

import com.tledu.spring01.model.User;

/**
 * 用户服务类接口
 */
public interface IUserService {
    User findUserById(Integer id);
}

UserServiceImpl

package com.tledu.spring01.service.impl;

import com.tledu.spring01.dao.IUserDao;
import lombok.Setter;
import com.tledu.spring01.model.User;
import com.tledu.spring01.service.IUserService;

/**
 * @author Antg
 * @date 2021/8/511:02
 */
public class UserServiceImpl implements IUserService {
	//这里是使用setter的方式注入的,还有其他的方式
    @Setter
    private IUserDao userDao;//使用了spring的依赖注入,所以就不用new 对象了

    @Override
    public User findUserById(Integer id) {
        return userDao.findUserById(id);
    }
}

5.将需要交给spring管理的类注册到sping中

<?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 name="userDao" class="com.tledu.spring01.dao.impl.UserDaoImpl"></bean>
    <bean name="userService" class="com.tledu.spring01.service.impl.UserServiceImpl">
        <!--name中的userDao是service实现类中的属性名,ref中的名字是上面bean的名字-->
        <property name="userDao" ref="userDao"></property>
    </bean>
</beans>

6.创建测试代码

import com.tledu.spring01.service.IUserService;
import com.tledu.spring01.service.impl.UserServiceImpl;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 测试类
 *
 * @author Antg
 * @date 2021/8/511:09
 */
public class UserServiceTest {
    @Test
    public void test01() {
        //创建spring容器
        ClassPathXmlApplicationContext application = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取bean
        IUserService userService = application.getBean("userService", UserServiceImpl.class);
        //执行其中的方法
        userService.findUserById(10);
    }
}

三.总结

是不是特别牛,直接将创建对象这个步骤交给了spring容器去管理,如果之后需要在进行维护的话,只需要修改配置文件就可以,实现了解耦的目的,而且也让面向接口编程更加的方便.