测开学习笔记十一：spring

最新推荐文章于 2024-05-11 16:30:13 发布

qq_33214066

最新推荐文章于 2024-05-11 16:30:13 发布

阅读量130

点赞数

分类专栏： Java测开学习笔记文章标签： spring java spring boot

本文链接：https://blog.csdn.net/qq_33214066/article/details/120175155

版权

Java测开学习笔记专栏收录该内容

11 篇文章 5 订阅

订阅专栏

1.spring

1.1spring简介

Spring 自诞生以来一直备受青睐，它包括许多框架，例如 Spring framework、SpringMVC、SpringBoot、Spring Cloud、Spring Data、Spring Security 等，所以有人将它们亲切的称之为：Spring 全家桶。

Spring framework 就是我们平时说的 Spring 框架，Spring 是目前主流的 Java Web 开发框架，是 Java 世界最为成功的框架。该框架是一个轻量级的开源框架，具有很高的凝聚力和吸引力。

Spring 是分层的 Java SE/EE 一站式轻量级开源框架，以 IoC（Inverse of Control，控制反转）和 AOP（Aspect Oriented Programming，面向切面编程）为内核。

1.2 IoC

IoC 指的是将对象的创建权交给 Spring 去创建。使用 Spring 之前，对象的创建都是由我们使用 new 创建，而使用 Spring 之后，对象的创建都交给了 Spring 框架。
IoC 容器是 Spring 的核心，也可以称为 Spring 容器。Spring 通过 IoC 容器来管理对象的实例化和初始化，以及对象从创建到销毁的整个生命周期。
Spring 通过读取 XML 或 Java 注解中的信息来获取哪些对象需要实例化。
Spring 提供 2 种不同类型的 IoC 容器，即 BeanFactory 和 ApplicationContext 容器。

1.2.1 通过XML配置bean获取对象

package springmvc;

import lombok.Data;

@Data
public class User {
    int age;
    String name;
}

<?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 class="springmvc.User" id="user"></bean>

</beans>

package springmvc;

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

public class IoCTest {
    public static void main(String[] args) {
        //控制反转：以前自己new对象，现在交给spring new对象
        ApplicationContext context = new ClassPathXmlApplicationContext("ioc.xml");
        Object object =context.getBean("user");
        System.out.println(object);

    }
}

在这里插入图片描述

1.2.2 通过扫描包+注解获取对象

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

    <!-- ioc 第一种种方式 自己配置bean -->
    <bean class="springmvc.User" id="user"></bean>

    <!-- ioc 第二种方式 扫描包 -->
    <context:component-scan base-package="springmvc"/>

</beans>

package springmvc;

import lombok.Data;
import org.springframework.stereotype.Component;


@Data
@Component//让sping去扫描注解
public class Car {
    int productName;
    int color;
}

package springmvc;

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

public class IoCTest {
    public static void main(String[] args) {
        //控制反转：以前自己new对象，现在交给spring new对象
        ApplicationContext context = new ClassPathXmlApplicationContext("ioc.xml");
        Object object =context.getBean("user");
        System.out.println(object);
        Car car = (Car) context.getBean("car");
        System.out.println(car);
    }
}

1.3 DI（依赖注入）

Spring 容器在创建被调用者的实例时，会自动将调用者需要的对象实例注入给调用者，调用者通过 Spring 容器获得被调用者实例，这称为依赖注入。
DI的三种方式：
setter注入、构造器注入和基于注解的注入

1.3.1 setter注入

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

    <!-- ioc 第一种种方式 自己配置bean -->
    <bean class="springmvc.User" id="user">
        <!-- setter注入 -->
        <property name="car" ref="carTest"></property>
    </bean>

    <!-- ioc 第二种方式 扫描包 -->
    <context:component-scan base-package="springmvc"/>

</beans>

package springmvc;

import lombok.Data;
import org.springframework.stereotype.Component;


@Data
@Component(value = "carTest")//让sping去扫描注解
public class Car {
    int productName;
    int color;
}

package springmvc;

import lombok.Data;

@NoArgsConstructor
@AllArgsConstructor
@Data
public class User {
    int age;
    String name;
    private Car car;
}

package springmvc;

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

public class IoCTest {
    public static void main(String[] args) {
        //控制反转：以前自己new对象，现在交给spring new对象
        ApplicationContext context = new ClassPathXmlApplicationContext("ioc.xml");
        Object object =context.getBean("user");
        System.out.println(object);
        Car car = (Car) context.getBean("carTest");
        System.out.println(car);
    }
}

1.3.2 构造器注入

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

    <!-- ioc 第一种种方式 自己配置bean -->
    <bean class="springmvc.User" id="user">
        <constructor-arg name="age" value="1"></constructor-arg>
        <constructor-arg name="name" value="22"></constructor-arg>
        <constructor-arg  ref="carTest"></constructor-arg>
    </bean>

    <!-- ioc 第二种方式 扫描包 -->
    <context:component-scan base-package="springmvc"/>

</beans>

在这里插入图片描述

1.3.3 基于注解的注入

package springmvc;


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

@Data
@Component(value = "bus")
public class Bus {
    String name;
    @Autowired
    private Car car;
}

在这里插入图片描述

1.3 属性管理

读取读取xxx.properties文件中的数据,两种方式：
1.添加属性文件，配置属性

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

    <!-- ioc 第一种种方式 自己配置bean -->
    <bean class="springmvc.User" id="user">
        <constructor-arg name="age" value="${myage}"></constructor-arg>
        <constructor-arg name="name" value="${myname}"></constructor-arg>
        <constructor-arg  ref="carTest"></constructor-arg>
    </bean>

    <!-- ioc 第二种方式 扫描包 -->
    <context:component-scan base-package="springmvc"/>
    <!-- 读取配置文件 -->
    <context:property-placeholder
            location="classpath:appilcation.properties" />

</beans>

2.使用@value注解

package springmvc;


import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Data
@Component(value = "bus")
public class Bus {

    @Value("${mycolor}")
    String name;
    @Autowired
    private Car car;
}

1.4 dbutils整合

方式一：配置bean对象

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

    <!-- 定义数据源Bean-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
        <property name="driverClass" value="${jdbc.driverClass}" />
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="user" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>
    <!-- 方式1-->
    <bean id="dbUtilsTemplate" class="com.testfan.utils.DbUtilsTemplate">
        <property name="dataSource" ref="dataSource" />
    </bean>


    <!-- ioc 第二种方式 扫描包 -->
    <context:component-scan base-package="springmvc"/>
    <!-- 读取配置文件 -->
    <context:property-placeholder
            location="classpath:jdbc.properties" />

</beans>

package com.testfan.utils;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.sql.DataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

public class DbUtilsTemplate {

    private DataSource dataSource;

    private QueryRunner queryRunner;
    private static final Log LOG = LogFactory.getLog(DbUtilsTemplate.class);

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }


    /**
     * 执行sql语句
     * @param sql sql语句
     * @param params 参数数组
     * @return 受影响的行数
     */
    public int update(String sql, Object... params) {
        queryRunner = new QueryRunner(dataSource);
        int affectedRows = 0;
        try {
            if (params == null) {
                affectedRows = queryRunner.update(sql);
            } else {
                affectedRows = queryRunner.update(sql, params);
            }
        } catch (SQLException e) {
            LOG.error("Error occured while attempting to update data", e);
        }
        return affectedRows;
    }

    /**
     * 执行批量sql语句
     * @param sql sql语句
     * @param params 二维参数数组
     * @return 受影响的行数的数组
     */
    public int[] batchUpdate(String sql, Object[][] params) {
        queryRunner = new QueryRunner(dataSource);
        int[] affectedRows = new int[0];
        try {
            affectedRows = queryRunner.batch(sql, params);
        } catch (SQLException e) {
            LOG.error("Error occured while attempting to batch update data", e);
        }
        return affectedRows;
    }


    /**
     * 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
     * @param sql sql语句
     * @param params 参数数组
     * @return 查询结果
     */
    @SuppressWarnings("unchecked")
    public List<Map<String, Object>> findListMap(String sql, Object... params) {
        queryRunner = new QueryRunner(dataSource);
        List<Map<String, Object>> list = new ArrayList<Map<String,Object>>();
        try {
            if (params == null) {
                list = (List<Map<String, Object>>) queryRunner.query(sql, new MapListHandler());
            } else {
                list = (List<Map<String, Object>>) queryRunner.query(sql, new MapListHandler(), params);
            }
        } catch (SQLException e) {
            LOG.error("Error occured while attempting to query data", e);
        }
        return list;
    }

    /**
     * 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中
     * @param entityClass 类名
     * @param sql sql语句
     * @param params 参数数组
     * @return 查询结果
     */
    @SuppressWarnings("unchecked")
    public <T> List<T> findList(String sql,Class<T> entityClass, Object... params) {
        queryRunner = new QueryRunner(dataSource);
        List<T> list = new ArrayList<T>();
        try {
            if (params == null) {
                list = (List<T>) queryRunner.query(sql, new BeanListHandler(entityClass));
            } else {
                list = (List<T>) queryRunner.query(sql, new BeanListHandler(entityClass), params);
            }
        } catch (SQLException e) {
            LOG.error("Error occured while attempting to query data", e);
        }
        return list;
    }



    /**
     * 查询出结果集中的第一条记录，并封装成对象
     * @param entityClass 类名
     * @param sql sql语句
     * @param params 参数数组
     * @return 对象
     */
    @SuppressWarnings("unchecked")
    public <T> T findOne(String sql, Class<T> entityClass, Object... params) {
        queryRunner = new QueryRunner(dataSource);
        Object object = null;
        try {
            if (params == null) {
                object = queryRunner.query(sql, new BeanHandler(entityClass));
            } else {
                object = queryRunner.query(sql, new BeanHandler(entityClass), params);
            }
        } catch (SQLException e) {
            LOG.error("Error occured while attempting to query data", e);
        }
        return (T) object;
    }

    /**
     * 查询出结果集中的第一条记录，并封装成Map对象
     * @param sql sql语句
     * @return 封装为Map的对象
     */
    public Map<String, Object> findFirst(String sql) {
        return findFirst(sql, null);
    }

    /**
     * 查询出结果集中的第一条记录，并封装成Map对象
     * @param sql sql语句
     * @param param 参数
     * @return 封装为Map的对象
     */
    public Map<String, Object> findFirst(String sql, Object param) {
        return findFirst(sql, new Object[] { param });
    }

    /**
     * 查询出结果集中的第一条记录，并封装成Map对象
     * @param sql sql语句
     * @param params 参数数组
     * @return 封装为Map的对象
     */
    @SuppressWarnings("unchecked")
    public Map<String, Object> findFirst(String sql, Object[] params) {
        queryRunner = new QueryRunner(dataSource);
        Map<String, Object> map = null;
        try {
            if (params == null) {
                map = (Map<String, Object>) queryRunner.query(sql, new MapHandler());
            } else {
                map = (Map<String, Object>) queryRunner.query(sql, new MapHandler(), params);
            }
        } catch (SQLException e) {
            LOG.error("Error occured while attempting to query data", e);
        }
        return map;
    }

    /**
     * 查询某一条记录，并将指定列的数据转换为Object
     * @param sql sql语句
     * @param columnName 列名
     * @return 结果对象
     */
    public Object findBy(String sql, String columnName) {
        return findBy(sql, columnName, null);
    }

    /**
     * 查询某一条记录，并将指定列的数据转换为Object
     * @param sql sql语句
     * @param columnName 列名
     * @param param 参数
     * @return 结果对象
     */
    public Object findBy(String sql, String columnName, Object param) {
        return findBy(sql, columnName, new Object[] { param });
    }

    /**
     * 查询某一条记录，并将指定列的数据转换为Object
     * @param sql sql语句
     * @param columnName 列名
     * @param params 参数数组
     * @return 结果对象
     */
    public Object findBy(String sql, String columnName, Object[] params) {
        queryRunner = new QueryRunner(dataSource);
        Object object = null;
        try {
            if (params == null) {
                object = queryRunner.query(sql, new ScalarHandler(columnName));
            } else {
                object = queryRunner.query(sql, new ScalarHandler(columnName), params);
            }
        } catch (SQLException e) {
            LOG.error("Error occured while attempting to query data", e);
        }
        return object;
    }

    /**
     * 查询某一条记录，并将指定列的数据转换为Object
     * @param sql sql语句
     * @param columnIndex 列索引
     * @return 结果对象
     */
    public Object findBy(String sql, int columnIndex) {
        return findBy(sql, columnIndex, null);
    }

    /**
     * 查询某一条记录，并将指定列的数据转换为Object
     * @param sql sql语句
     * @param columnIndex 列索引
     * @param param 参数
     * @return 结果对象
     */
    public Object findBy(String sql, int columnIndex, Object param) {
        return findBy(sql, columnIndex, new Object[] { param });
    }

    /**
     * 查询某一条记录，并将指定列的数据转换为Object
     * @param sql sql语句
     * @param columnIndex 列索引
     * @param params 参数数组
     * @return 结果对象
     */
    public Object findBy(String sql, int columnIndex, Object[] params) {
        queryRunner = new QueryRunner(dataSource);
        Object object = null;
        try {
            if (params == null) {
                object = queryRunner.query(sql, new ScalarHandler(columnIndex));
            } else {
                object = queryRunner.query(sql, new ScalarHandler(columnIndex), params);
            }
        } catch (SQLException e) {
            LOG.error("Error occured while attempting to query data", e);
        }
        return object;
    }

}

package springmvc;

import com.testfan.utils.DbUtilsTemplate;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.Map;

public class IoCTest {
    public static void main(String[] args) {
        //控制反转：以前自己new对象，现在交给spring new对象
        ApplicationContext context = new ClassPathXmlApplicationContext("ioc.xml");
        DbUtilsTemplate utilsTemplate = (DbUtilsTemplate) context.getBean("dbUtilsTemplate");
        Map<String, Object> objectMap= utilsTemplate.findFirst("select * from idcard_infos");
        System.out.println(objectMap);
    }
}

在这里插入图片描述

参照博客：https://www.cnblogs.com/sunxucool/archive/2013/03/05/2944011.html

方式二：使用注解

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

    <!-- 定义数据源Bean-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
        <property name="driverClass" value="${jdbc.driverClass}" />
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="user" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>
    <!-- 第二种扫描方式 -->
    <context:component-scan base-package="com.testfan.utils" />
    <!-- 读取配置文件 -->
    <context:property-placeholder
            location="classpath:jdbc.properties" />

</beans>

package com.testfan.utils;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.sql.DataSource;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service("dbUtilsTemplate")
public class DbUtilsTemplate {

    @Autowired
    private DataSource dataSource;

    private QueryRunner queryRunner;
    private static final Log LOG = LogFactory.getLog(DbUtilsTemplate.class);

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }


    /**
     * 执行sql语句
     * @param sql sql语句
     * @param params 参数数组
     * @return 受影响的行数
     */
    public int update(String sql, Object... params) {
        queryRunner = new QueryRunner(dataSource);
        int affectedRows = 0;
        try {
            if (params == null) {
                affectedRows = queryRunner.update(sql);
            } else {
                affectedRows = queryRunner.update(sql, params);
            }
        } catch (SQLException e) {
            LOG.error("Error occured while attempting to update data", e);
        }
        return affectedRows;
    }

    /**
     * 执行批量sql语句
     * @param sql sql语句
     * @param params 二维参数数组
     * @return 受影响的行数的数组
     */
    public int[] batchUpdate(String sql, Object[][] params) {
        queryRunner = new QueryRunner(dataSource);
        int[] affectedRows = new int[0];
        try {
            affectedRows = queryRunner.batch(sql, params);
        } catch (SQLException e) {
            LOG.error("Error occured while attempting to batch update data", e);
        }
        return affectedRows;
    }


    /**
     * 执行查询，将每行的结果保存到一个Map对象中，然后将所有Map对象保存到List中
     * @param sql sql语句
     * @param params 参数数组
     * @return 查询结果
     */
    @SuppressWarnings("unchecked")
    public List<Map<String, Object>> findListMap(String sql, Object... params) {
        queryRunner = new QueryRunner(dataSource);
        List<Map<String, Object>> list = new ArrayList<Map<String,Object>>();
        try {
            if (params == null) {
                list = (List<Map<String, Object>>) queryRunner.query(sql, new MapListHandler());
            } else {
                list = (List<Map<String, Object>>) queryRunner.query(sql, new MapListHandler(), params);
            }
        } catch (SQLException e) {
            LOG.error("Error occured while attempting to query data", e);
        }
        return list;
    }

    /**
     * 执行查询，将每行的结果保存到Bean中，然后将所有Bean保存到List中
     * @param entityClass 类名
     * @param sql sql语句
     * @param params 参数数组
     * @return 查询结果
     */
    @SuppressWarnings("unchecked")
    public <T> List<T> findList(String sql,Class<T> entityClass, Object... params) {
        queryRunner = new QueryRunner(dataSource);
        List<T> list = new ArrayList<T>();
        try {
            if (params == null) {
                list = (List<T>) queryRunner.query(sql, new BeanListHandler(entityClass));
            } else {
                list = (List<T>) queryRunner.query(sql, new BeanListHandler(entityClass), params);
            }
        } catch (SQLException e) {
            LOG.error("Error occured while attempting to query data", e);
        }
        return list;
    }



    /**
     * 查询出结果集中的第一条记录，并封装成对象
     * @param entityClass 类名
     * @param sql sql语句
     * @param params 参数数组
     * @return 对象
     */
    @SuppressWarnings("unchecked")
    public <T> T findOne(String sql, Class<T> entityClass, Object... params) {
        queryRunner = new QueryRunner(dataSource);
        Object object = null;
        try {
            if (params == null) {
                object = queryRunner.query(sql, new BeanHandler(entityClass));
            } else {
                object = queryRunner.query(sql, new BeanHandler(entityClass), params);
            }
        } catch (SQLException e) {
            LOG.error("Error occured while attempting to query data", e);
        }
        return (T) object;
    }

    /**
     * 查询出结果集中的第一条记录，并封装成Map对象
     * @param sql sql语句
     * @return 封装为Map的对象
     */
    public Map<String, Object> findFirst(String sql) {
        return findFirst(sql, null);
    }

    /**
     * 查询出结果集中的第一条记录，并封装成Map对象
     * @param sql sql语句
     * @param param 参数
     * @return 封装为Map的对象
     */
    public Map<String, Object> findFirst(String sql, Object param) {
        return findFirst(sql, new Object[] { param });
    }

    /**
     * 查询出结果集中的第一条记录，并封装成Map对象
     * @param sql sql语句
     * @param params 参数数组
     * @return 封装为Map的对象
     */
    @SuppressWarnings("unchecked")
    public Map<String, Object> findFirst(String sql, Object[] params) {
        queryRunner = new QueryRunner(dataSource);
        Map<String, Object> map = null;
        try {
            if (params == null) {
                map = (Map<String, Object>) queryRunner.query(sql, new MapHandler());
            } else {
                map = (Map<String, Object>) queryRunner.query(sql, new MapHandler(), params);
            }
        } catch (SQLException e) {
            LOG.error("Error occured while attempting to query data", e);
        }
        return map;
    }

    /**
     * 查询某一条记录，并将指定列的数据转换为Object
     * @param sql sql语句
     * @param columnName 列名
     * @return 结果对象
     */
    public Object findBy(String sql, String columnName) {
        return findBy(sql, columnName, null);
    }

    /**
     * 查询某一条记录，并将指定列的数据转换为Object
     * @param sql sql语句
     * @param columnName 列名
     * @param param 参数
     * @return 结果对象
     */
    public Object findBy(String sql, String columnName, Object param) {
        return findBy(sql, columnName, new Object[] { param });
    }

    /**
     * 查询某一条记录，并将指定列的数据转换为Object
     * @param sql sql语句
     * @param columnName 列名
     * @param params 参数数组
     * @return 结果对象
     */
    public Object findBy(String sql, String columnName, Object[] params) {
        queryRunner = new QueryRunner(dataSource);
        Object object = null;
        try {
            if (params == null) {
                object = queryRunner.query(sql, new ScalarHandler(columnName));
            } else {
                object = queryRunner.query(sql, new ScalarHandler(columnName), params);
            }
        } catch (SQLException e) {
            LOG.error("Error occured while attempting to query data", e);
        }
        return object;
    }

    /**
     * 查询某一条记录，并将指定列的数据转换为Object
     * @param sql sql语句
     * @param columnIndex 列索引
     * @return 结果对象
     */
    public Object findBy(String sql, int columnIndex) {
        return findBy(sql, columnIndex, null);
    }

    /**
     * 查询某一条记录，并将指定列的数据转换为Object
     * @param sql sql语句
     * @param columnIndex 列索引
     * @param param 参数
     * @return 结果对象
     */
    public Object findBy(String sql, int columnIndex, Object param) {
        return findBy(sql, columnIndex, new Object[] { param });
    }

    /**
     * 查询某一条记录，并将指定列的数据转换为Object
     * @param sql sql语句
     * @param columnIndex 列索引
     * @param params 参数数组
     * @return 结果对象
     */
    public Object findBy(String sql, int columnIndex, Object[] params) {
        queryRunner = new QueryRunner(dataSource);
        Object object = null;
        try {
            if (params == null) {
                object = queryRunner.query(sql, new ScalarHandler(columnIndex));
            } else {
                object = queryRunner.query(sql, new ScalarHandler(columnIndex), params);
            }
        } catch (SQLException e) {
            LOG.error("Error occured while attempting to query data", e);
        }
        return object;
    }

}

1.4.1 .xml文件存在多个数据源怎么办

独立的 Autowired
组合 Autowired+Qualifier
组合 @Resource
在这里插入图片描述
备注：
@Autowired与@Resource都可以用来装配bean. 都可以写在字段上,或写在setter方法上
@Autowired默认按类型装配（这个注解是属业spring的），默认情况下必须要求依赖对象必须存在，如果要允许null 值，可以设置它的required属性为false，如：@Autowired(required=false)
当使用@autowired注解时，由于是按类型进行匹配，并不能确定具体使用哪一个bean或者是具体的那个子类，所以要引入@qualifier来指定具体选取那个bean来进行注入操作。
@Resource（这个注解属于J2EE的），默认安照名称进行装配，名称可以通过name属性进行指定

2.SpringMVC数据库读取和展现

在这里插入图片描述

package com.testfan.idcard;


import com.testfan.utils.DbUtilsTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.servlet.ModelAndView;

import java.util.List;

@Controller
public class DbController {

    @Autowired
    DbUtilsTemplate dbUtilsTemplate;

    @GetMapping("db")
    public ModelAndView toDb(){
        List<IdCard> list = dbUtilsTemplate.findList("select * from idcard_infos",IdCard.class);
        System.out.println("list:"+list);
        ModelAndView modelAndView= new ModelAndView("idCard");
        modelAndView.addObject("idcardList",list);
        return modelAndView;
    }
}

运行结果：
在这里插入图片描述
接口返回结果是json

package com.testfan.idcard;


import com.testfan.utils.DbUtilsTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import java.util.List;

@Controller
public class DbController {

    @Autowired
    DbUtilsTemplate dbUtilsTemplate;

    @GetMapping("db")
    public ModelAndView toDb(){
        List<IdCard> list = dbUtilsTemplate.findList("select * from idcard_infos",IdCard.class);
        System.out.println("list:"+list);
        ModelAndView modelAndView= new ModelAndView("idCard");
        modelAndView.addObject("idcardList",list);
        return modelAndView;
    }

    @GetMapping("db2")
    @ResponseBody
    public List toDbJson(){
        List<IdCard> list = dbUtilsTemplate.findList("select * from idcard_infos",IdCard.class);
        return list;
    }
}

在这里插入图片描述

3.resultful风格接口

3.1 resultful风格简介

resultful风格是一种软件架构风格，而不是标准，只是提供了一种设计原则和约束条件。主要适用于客户端和服务器端交互的软件。是基于http协议实现。目的是为了提高系统的可伸缩性，降低应用之间的耦合度，方便框架分布式处理程序。基于这个风格的软件可更加的简单、更有层次，更易于实现缓存的机制。
GET，对应select:是从服务器查询，可以在服务器通过请求的参数区分查询的方式。
POST,对应Create:在服务器新建立一个资源，调用insert操作。
PUT，对应update操作:在服务器更新资源，调用update操作。
DELETE，对应DELETE操作，从服务器删除资源，调用delete语句

3.2spring mvc中实现resultful风格接口

Spring MVc 对resstful应用提供了以下支持。利用@RequestMapping 指定要处理请求的url模板和http请求的动作类型。利用@PathVariable将url请求模板中的变量映射到处理方法参数上。前台利用AJAX，在客户端发出put、delete动作的请求。

一般的应用格式如下：
@RequestMapping(value="/{id}",method=RequestMethod.GET)
@RequestMapping(value="/{id}",method=RequestMethod.POST)
@RequestMapping(value="/{id}",method=RequestMethod.DELETE)
@RequestMapping(value="/{id}",method=RequestMethod.PUT)

4. spring数据库包替换工具类DbUtilsTemplate

pom文件新导入包

<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>5.1.9.RELEASE</version>
			<scope>provided</scope>
		</dependency>

xml文件配置spring 的 JdbcTemplate

<!-- 配置 spring 的 JdbcTemplate -->
    <bean id="jdbcTemplate"
          class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

新增接口测试

package com.testfan.idcard;


import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController//Controller+RequestBody
public class JdbcController {
    @Autowired
    JdbcTemplate jdbcTemplate;//模版设计

    @GetMapping("db3")
    @ResponseBody
    public List toDbJson(){
        String sql="select * from idcard_infos";
        RowMapper<IdCard> rowMapper = new BeanPropertyRowMapper<>(IdCard.class);
        List<IdCard> list = jdbcTemplate.query(sql,rowMapper);
        return list;
    }
}

运行结果：
在这里插入图片描述

5.spring+testng

package mytest;



import com.testfan.idcard.IdCard;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.testng.annotations.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;

import java.util.List;

//白盒测试
@ContextConfiguration(locations= {"classpath:spring_db.xml"})//加载核心配置文件
public class MyJdbcTest extends AbstractTestNGSpringContextTests {
    //spring提供的
    @Autowired
    JdbcTemplate jdbcTemplate;//模版设计

    @Test
    public void testFindString() {
        String sql="select * from idcard_infos";
        RowMapper<IdCard> rowMapper = new BeanPropertyRowMapper<>(IdCard.class);
        List<IdCard> list = jdbcTemplate.query(sql,rowMapper);
        System.out.println(list);
    }



}

参考博客：https://www.yiibai.com/testng/testng-spring-integration.html

qq_33214066

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
测开学习笔记十一：spring

1.spring1.1spring简介Spring 自诞生以来一直备受青睐，它包括许多框架，例如 Spring framework、SpringMVC、SpringBoot、Spring Cloud、Spring Data、Spring Security 等，所以有人将它们亲切的称之为：Spring 全家桶。Spring framework 就是我们平时说的 Spring 框架，Spring 是目前主流的 Java Web 开发框架，是 Java 世界最为成功的框架。该框架是一个轻量级的开源框架，具有
复制链接

扫一扫