Spring框架基础介绍

< dependency >

< groupId >org.springframework</ groupId >

< artifactId >spring-context</ artifactId >

< version >5.2.2.RELEASE</ version >

</ dependency >

spring bean 管理

bean对象，由于把对象交给spring管理后，spring会对对象进行 功能的增强，

所以在spring框架中生成的对象，统一称为 bean对象。

区分这个对象是我们自己new的还是spring框架生成的。

编写 spring 配置文件

 使用bean标签，配置需要让spring管理的类.
  id="对象名称，可以在getBean中获得spring生成的对象".
  class="需要让spring管理的类的地址".
  scope="配置bean的作用域".
  scope="singleton"=>单例的(默认) （在spring框架启动时，就创建对象，而且始终只创建了一个对象。）
  scope="prototype"=>原型的（多例的） 在每次获得对象时，创建一个新的对象.

<?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">

 <!--在spring的配置文件注册需要spring框架管理的类-->

        <bean id="admin" class="com.ffyc.springpro.model.Admin" scope="singleton" >

</beans>

编写一个 User 实体类

测试 spring

package com.ffyc.springpro.test;

import com.ffyc.springpro.model.Admin;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    public static void main(String[] args) {
        //Admin admin=new Admin();
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
        Admin admin=(Admin) applicationContext.getBean("admin");
        Admin admin1=applicationContext.getBean("admin",Admin.class);
        System.out.println(admin);
        System.out.println(admin1);
    }
}

IOC(控制反转)

IOC:指的是让spring框架创建对象，创建对象的同时，还有一个动作称为依赖注入。

依赖注入：

依赖注入是指在创建对象的时候，为对象中属性赋值。
依赖注入有两种方式：
   1、通过属性注入，（属性的set方法注入）
   2、通过构造方法注入

1、通过属性注入

（属性的set方法注入）

<!--通过get，set方法注入-->
<property name="account" value="admin"></property>
<property name="password" value="1111"></property>

2、通过构造方法注入

<!--通过构造方法注入-->
<constructor-arg name="account" value="admin1"></constructor-arg>
<constructor-arg name="password" value="1212"></constructor-arg>

spring中bean管理

有两种方式。

1、基于xml配置方式

id="对象名称，可以在getBean中获得spring生成的对象"。
class="需要让spring管理的类的地址"。
scope="配置bean的作用域".。

scope="singleton"=>单例的(默认) （在spring框架启动时，就创建对象，而且始终只创建了一个对象。）

scope="prototype"=>原型的（多例的）在每次获得对象时，创建一个新的对象。

request: 每次 http 请求都会创建一个 bean, 仅用于 WebApplicationContext 环境。

<?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">


          <!--在spring的配置文件注册需要spring框架管理的类
               使用bean标签，配置需要让spring管理的类
               id="对象名称，可以在getBean中获得spring生成的对象"
               class="需要让spring管理的类的地址"
               scope="配置bean的作用域"
               scope="singleton"=>单例的(默认) （在spring框架启动时，就创建对象，而且始终只创建了一个对象。）
               scope="prototype"=>原型的（多例的） 在每次获得对象时，创建一个新的对象

              IOC:指的是让spring框架创建对象，创建对象的同时，还有一个动作称为依赖注入。
             依赖注入：在创建对象的时候，为对象中属性赋值
             依赖注入有两种方式：
                1、通过属性注入，（属性的set方法注入）
                2、通过构造方法注入

          -->
    <bean id="admin" class="com.ffyc.springpro.model.Admin" scope="singleton" >
        <!--通过get，set方法注入-->
<!--        <property name="account" value="admin"></property>-->
<!--        <property name="password" value="1111"></property>-->
        <!--通过构造方法注入-->
        <constructor-arg name="account" value="admin1"></constructor-arg>
        <constructor-arg name="password" value="1212"></constructor-arg>
    </bean>

    <bean id="adminDao" class="com.ffyc.springpro.dao.AdminDao"></bean>
    <bean id="adminService" class="com.ffyc.springpro.service.AdminService">
        <!--name="adminDao"拿到是adminService中的属性名对应   ref="adminDao"引用的是id为adminDao的AdminDao中的对象 注入进来    -->
        <property name="adminDao" ref="adminDao"></property>

    </bean>
</beans>

2、基于注解方式

首先开启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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           https://www.springframework.org/schema/context/spring-context.xsd">


<!--    开启spring注解扫描功能  指定扫描的包-->
    <context:component-scan base-package="com.ffyc.springpro"> </context:component-scan>
</beans>

添加注解标签：

@Component(value = "admin")
@Scope(value = "prototype")

不同层用不同的注解标签

@Repository(value = "adminDao")
@Service(value = "adminService")
@Autowired

package com.ffyc.springpro.model;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

//等同于xml中 <bean id="admin" class="com.ffyc.springpro.model.Admin" scope="singleton" >
@Component(value = "admin")
@Scope(value = "prototype")//scope=""
public class Admin {
    private String account;
    private String password;

    public Admin() {
        System.out.println("无参");
    }

    public Admin(String account, String password) {
        this.account = account;
        this.password = password;
        System.out.println("有参");
    }

    public String getAccount() {
        return account;
    }

    public void setAccount(String account) {
        System.out.println("setAccount");
        this.account = account;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        System.out.println("setPassword");
        this.password = password;
    }

    @Override
    public String toString() {
        return "Admin{" +
                "account='" + account + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

在一个类中要用到另外的类通过注解标签来自动注入

@Autowired

spring注解方式Bean管理,自动注入。
   @Autowired 是spring框架提供的注解，用于在属性和属性的set方法上，如果写在属性上，set方法都可以不需要了。
   默认情况下，要注入的值不能为空。默认值 ：required==true;
自动注入有两种值的匹配方式：
    1、通过属性的类型查找
    2、通过对象的名字查找
        @Qualifier(value = "adminDao")

@Resource

@Resource 是java语言中提供的注解标签
     也是添加在属性上，不需要写set方法。
     注入的值也不能为空。
     可以通过属性的类型查找。
     也可以通过对象的名字查找。

package com.ffyc.springpro.service;

import com.ffyc.springpro.dao.AdminDao;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service(value = "adminService")
public class AdminService {

    /*
         spring注解方式Bean管理  自动注入
             @Autowired 是spring框架提供的注解，用于在属性和属性的set方法上，如果写在属性上，set方法都可以不需要了。
             默认情况下，要注入的值不能为空。required==true;默认值

        自动注入有两种值的匹配方式：
            1、通过属性的类型查找
            2、通过对象的名字查找
                @Qualifier(value = "adminDao")


             @Resource 是java语言中提供的注解标签
                  也是添加在属性上，不需要写set方法。
                  注入的值也不能为空。
                  可以通过属性的类型查找。
                  也可以通过对象的名字查找。



     */
    //@Autowired
    //@Qualifier(value = "adminDao")

    @Resource
    //@Resource(name = "adminDao")
    AdminDao adminDao;

    public void saveAdmin(){
        adminDao.saveAdmin();
    }
}

Spring 数据访问层管理

Spring 是个一站式框架：Spring 自身也提供了 web 层的 SpringWeb 和持久层的 Spring JdbcTemplate。

导入包

下载 Spring jdbc 数据访问层 jar 包

<!-- spring-jdbc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.2.RELEASE</version>
</dependency>

<!--mysql-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.16</version>
</dependency>

<!-- 阿里巴巴数据库链接管理组件 专门负责创建数据库链接的操作-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>

管理数据源对象

<!--
阿里巴巴数据库连接管理对象，负责生成数据库连接对象，以及提供数据库链接池功能
接下俩让spring管理阿里巴巴数据库连接对象。
-->

<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://127.0.0.1:3306/ssmdb?serverTimezone=Asia/Shanghai"></property>
    <property name="username" value="root"></property>
    <property name="password" value="root"></property>
    <property name="initialSize" value="10"></property><!--初始化连接数量-->
    <property name="maxActive" value="20"></property><!--最大连接数量-->
</bean>

配置spring中对jdbc进行封装的操作类型：

  <!--
      配置spring中对jdbc进行封装的操作类型  JdbcTemplate
   -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
       <!--JdbcTemplate定义的属性名-->
    <property name="dataSource" ref="druidDataSource"></property>
</bean>

package com.ffyc.springpro.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
//不同层使用不同的标签
@Repository//(value = "adminDao")
public class AdminDao {

    @Autowired
    JdbcTemplate jdbcTemplate;

    public void saveAdmin(){
        //jdbcTemplate.execute("create table ");//主要实行创建表的ddl语句，没有返回值
        jdbcTemplate.update("insert into admin(account,password,gender) values (?,?,?)","张山","11212","女");
    }
}

Spring 集成 Mybatis

Spring 集成 Mybatis 其核心是将 SqlSessionFactory 交由 Spring 管理，并由

Spring 管理对 dao 接口的代理实现。

1、导入 mybatis jar 包

Spring 结合 mybatis 插件包等等

<?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.example</groupId>
    <artifactId>ssm</artifactId>
    <version>1.0-SNAPSHOT</version>
    <name>ssm</name>
    <packaging>war</packaging>

    <properties>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.source>1.8</maven.compiler.source>
        <junit.version>5.6.2</junit.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>javax</groupId>
            <artifactId>javaee-web-api</artifactId>
            <version>8.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>${junit.version}</version>
            <scope>test</scope>
        </dependency>

        <!-- spring-context spring核心jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>

        <!-- spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.16</version>
        </dependency>

        <!-- 阿里巴巴数据库链接管理组件 专门负责创建数据库链接的操作-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.2</version>
        </dependency>

        <!--Spring 结合 mybatis 插件包-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.1</version>
        </dependency>


        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.10</version>
        </dependency>


    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.3.0</version>
            </plugin>
        </plugins>
    </build>
</project>

2、配置 sqlSessionFactory

3、指定生成接口代理

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


    <!--开启spring注解扫描功能  指定扫描的包-->
    <context:component-scan base-package="com.ffyc.ssm"> </context:component-scan>
    <!--
    阿里巴巴数据库连接管理对象，负责生成数据库连接对象，以及提供数据库链接池功能
    让spring管理阿里巴巴数据库连接对象-->
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://127.0.0.1:3306/ssmdb?serverTimezone=Asia/Shanghai"></property>
        <property name="username" value="root"></property>
        <property name="password" value="root"></property>
        <property name="initialSize" value="10"></property><!--初始化连接数量-->
        <property name="maxActive" value="20"></property><!--最大连接数量-->
    </bean>

    <!--往spring管理生成SqlSessionFactory对象-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="druidDataSource"></property><!--注入数据源-->
        <property name="configLocation" value="classpath:mybatis.xml"></property><!--配置mybatis配置文件-->
        <property name="mapperLocations" value="classpath:mappers/LoginDao.xml"><!--扫描mappers映射文件-->
        </property>
    </bean>


    <!--生成dao包下所有接口的代理对象 指定生成接口代理-->
    <bean id="mapperFactory" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.ffyc.ssm.dao"></property>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory">
        </property>
    </bean>

</beans>

4、在 service 中注入 Dao 代理接口，此接口有 Spring 代理实现

package com.ffyc.ssm.service;

import com.ffyc.ssm.dao.LoginDao;
import com.ffyc.ssm.model.Admin;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class LoginService {
    @Autowired
    LoginDao loginDao;

    public Admin login(Admin admin){
        Admin admin1=loginDao.login(admin);
        return admin1;
    }

}

Test测试

package com.ffyc.ssm.test;

import com.ffyc.ssm.model.Admin;
import com.ffyc.ssm.service.LoginService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    public static void main(String[] args) {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
        LoginService loginService=applicationContext.getBean("loginService",LoginService.class);

        Admin admin=new Admin();
        admin.setAccount("admin");
        admin.setPassword("111");

        Admin admin1=loginService.login(admin);
        System.out.println(admin1);
    }
}