Spring基础 实验报告 心得

学习目录

• 一.Spring框架认识

• 1.什么是Spring
• 2.Spring的优点

• 二.Spring环境搭建与第一个项目

• 环境搭建
• 第一个项目

• 三.IOC

• IOC理论推导
• 几种常见的属性注入方式
• 装配

• 四.AOP

• 什么是AOP呢？
• 第一种实现方式
• 第二种实现方式
• 第三种实现方式

• 五.Spring整合Mybatis

一.Spring框架认识

1.什么是Spring

Spring是一个开源的免费的框架（容器）！
Spring是一个轻量级的、非入侵式的框架！

2.Spring的优点

重点理解：1.控制反转（IOC），面向切面编程（AOP）。
		2.支持事务的处理，对框架整合的支持。

二.Spring环境搭建与第一个项目

环境搭建

需要导入以下依赖

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.0.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

自此环境就搭建完了，接下来就是第一个项目。

第一个项目

附上代码

public class HelloWorld {
    String target;

    public void setTarget(String target) {
        this.target = target;
    }

    public void show(){
        System.out.println("Hello"+this.target);
    }
}

通过spring来获取对象，及调用对象，存有问题解答。

1.hw对象是谁创建的？
	hw对象是spring容器创建的
	一个bean就相当与一个对象。
	
2.对象的属性target是谁赋予的？
	对象的属性是spring容器进行装配的。
	property标签就是属性赋值的操作

简单理解spring的第一个项目就是用spring容器创建了一个类的对象，然后通过特有的方式获取了这个被创建的对象，然后调用他的一系列方法。注意这里的对象只有一个，也就是单例模式。

三.IOC

IOC理论推导

Spring主要就是一个ioc控制反转，还有一个aop面向切面

ioc翻译过来是控制反转，意思就是把对象的创建还有装配以及管理从程序自身创建变为都交给了spring容器来做，程序员只需要按照对应的方式得到该有的对象

以前的程序都是要啥new啥，需要我们不断地修改源码。

比如：

创建一个Eat接口

以上就是以前的程序特点，如果调用不同的对象的eat()就得需要不断地修改源码

比如：

Eat person = new Student();
    Eat person = new Teacher();

而我们可以通过一个set方法解决需要不断修改源码的问题

由此可以发现，对象的创建由程序的主动创建变为了被动接收

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection，DI）

几种常见的属性注入方式

一.set注入

就是上面通过property注入

二.构造器注入

使用一个constructor-arg标签，示例：

Spring使用三步走

1.创建类

2.注入

3.测试

可以发现注入方式改变为通过构造器参数下表注入（从零开始），这就要求被装配的类需要有构造器。

主要就是这两种注入方式，还有就是p命名空间，c命名空间进行注入不过需要导入第三方约束

xmlns:p="http://www.springframework.org/schema/p"
 xmlns:c="http://www.springframework.org/schema/c"

导入第三方约束，通过p,c命名空间对bean进行注入

<bean id="user" class="com.kang.pojo.User" p:name="awei" p:age="21">
<bean id="user2" class="com.kang.pojo.User" c:name="lilei" c:age="20"/>

装配

现在基本都是用注解进行自动装配

示范一下手动装配。

示例：一个人有一条狗，一只猫。

三个类创建完毕，注入spring容器中然后用fer进行属性装配。

装配完毕测试

接下来使用注解装配

检查是否开启了注解支持导入第三方约束

确认无误，然后使用注解进行装配。

如下分别使用@Resource

注释掉以前的装配信息

测试

发现依然可以。

这两个注解，都是用来自动装配的，都可以放在属性字段上

@Autowired先通过byType后通过byName的方式实现，而且必须要求这个对象存在。

@Resource默认通过byName的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况才会报错。

四.AOP

什么是AOP呢？

aop（Aspect Oriented Programming）的意思就是面向切面编程，在开发时一般都是纵向开发，然而我们需要添加一些其他的信息，比如日志，就需要在不改变原有程序的基础上添加一些功能,也就是横向开发。

首先在pom.xml导入一个织入依赖

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
 beans/>

三种aop实现方式

第一种实现方式

通过java类实现这两个接口然后通过spring容器注册进去（记得先要导入aop相关依赖）

然后测试就行先通过classpathxmlapplicationContext的对象获取上下文再getBean就行然后执行就会达到aop效果环绕执行

第二种实现方式

自定义java类实现切面，然后通过spring容器注入再配置也可实现其效果

第三种实现方式

注解方式实现aop

五.Spring整合Mybatis

整合的关键就是核心配置文件的改变，mybatis主要使用来数据持久化，也就是与数据库打交道，spring则是与对象打交道，问题就是如何通过spring来执行sql语句呢？
新建一个maven项目在pom.xml中导入一下依赖

<dependencies>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.5.2</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.47</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>5.2.0.RELEASE</version>
            </dependency>
            <!--Spring操作数据库的话，还需要一个spring-jdbc
                   -->
            <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>5.2.0.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.8.13</version>
            </dependency>
            <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>2.0.2</version>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <version>1.18.10</version>
            </dependency>
        </dependencies>

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">


    <!--代替mybatis来管理数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8&useSSL=false"/>
        <property name="username" value="root"/>
        <property name="password" value="010323"/>
    </bean>

    <!--sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!--关联mybatis配置文件，不关联的话，mybatis配置文件中配置的实体类别名就无法生效-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <!--代替mybatis的映射器-->
        <property name="mapperLocations" value="classpath:com/kang/mapper/*.xml"/>
    </bean>

    <bean name="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能用构造器注入，因为源码中没有set方法，无法使用set注入-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>


</beans>

1.先写一个完整的mybatis项目。
2.将上面的配置文件作为新建配置文件导入recourse
3.在spring配置文件中导入这个配置文件
4.删除mybatis核心配置文件中environments标签，只留set,typealiases标签
5.创建Mapper接口的实现类并将sqlsessiontemplate私有化，并重写其要执行的方法，方法体为

UserMapper mapper = sqlSession.getMapper(实现的接口.class);
        return mapper.与sql命令对应的方法();

6.测试

总结：其实只要能拿到实现类的对象就可以完成很多东西，实现类实现了抽象方法，通过重写方法，关联到对应mybatis的xml文件中的sql语句。这样就直接可以通过实现类的对象.方法就可以实现spring管理数据库了.