03.spring的bean的配置,AOP,数据库的访问

最新推荐文章于 2023-01-09 21:29:42 发布

jv_xiaobai_yu

最新推荐文章于 2023-01-09 21:29:42 发布

阅读量151

点赞数

分类专栏： Spring学习文章标签： spring

本文链接：https://blog.csdn.net/ycjcson/article/details/112152607

版权

Spring学习专栏收录该内容

7 篇文章 0 订阅

订阅专栏

03.Springbean的配置,AOP,数据库的访问

一、Spring bean的配置

1、构造方法的反射

案例：

StuInfo.java

/**
 * 学生信息的实体信息类 (方式一)
 */
public class StuInfo {
    private String stuNo;
    private String stuName;
    private String stuAddress;
    private String stuEmail;
    public String getStuNo() {
        return stuNo;
    }
    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }
    public String getStuName() {
        return stuName;
    }
    public void setStuName(String stuName) {
        this.stuName = stuName;
    }
    public String getStuAddress() {
        return stuAddress;
    }
    public void setStuAddress(String stuAddress) {
        this.stuAddress = stuAddress;
    }
    public String getStuEmail() {
        return stuEmail;
    }
    public void setStuEmail(String stuEmail) {
        this.stuEmail = stuEmail;
    }
    @Override
    public String toString() {
        return "StuInfo{" +
                "stuNo='" + stuNo + '\'' +
                ", stuName='" + stuName + '\'' +
                ", stuAddress='" + stuAddress + '\'' +
                ", stuEmail='" + stuEmail + '\'' +
                '}';
    }
}

applicationContext01.xml

<!--Spring的Bean的配置-->
    <!-- set 方法反射创建 -->
    <bean id="stu1" class="com.yl.model1.StuInfo">
        <property name="stuNo" value="Java53001"/>
        <property name="stuName" value="张三"/>
        <property name="stuAddress" value="足下软件学院"/>
    </bean>

测试类

@Test
    public void testStu1(){
        // 读取配置文件，注入IOC容器
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext01.xml");
        StuInfo stu1 = context.getBean("stu1", StuInfo.class);
        System.out.println(stu1);
    }

2、工厂方法

（1）、静态工厂

通过某个静态方法来获取一个实例

案例：

StuInfoStaticFactory.java

/**
 *   静态工厂
 *          通过静态方法获取一个实例
 */
public class StuInfoStaticFactory {
    public static StuInfo getStuInfo(){
        StuInfo st = new StuInfo();
        st.setStuNo("java53002");
        st.setStuName("王二");
        st.setStuAddress("重庆市");
        return st;
    }
}

applicationContext01.xml

<!--
        配置静态工厂方法构建实例
            class:静态工厂类
            factory-method:工厂的静态方法
    -->
    <bean id="stu2" class="com.yl.model1.StuInfoStaticFactory" factory-method="getStuInfo"/>

测试

// 测试静态工厂模式
    @Test
    public void testStu2(){
        // 读取配置文件，注入IOC容器
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext01.xml");
        StuInfo stu2 = context.getBean("stu2", StuInfo.class);
        System.out.println(stu2);
    }

（2）、实例工厂

案例：

StuInfoFactory02.java

/**
 * 工厂方法
 *   实例工厂
 */
public class StuInfoFactory02 {
    public StuInfo getStuInfo(){
        StuInfo si = new StuInfo();
        si.setStuNo("java53003");
        si.setStuAddress("重庆市渝中区");
        return si;
    }
}

applicationContext01.xml

<!--
         配置实例工厂构建实例
            需要工厂的实例
            factory-bean:引用工厂的实例
            factory-method:工厂创建实例的方法的方法名
    -->
    <bean id="stuInfoFactory02" class="com.yl.model1.StuInfoFactory02"/>
    <bean id="stu3" factory-bean="stuInfoFactory02" factory-method="getStuInfo"/>

测试

// 测试实例工厂
    @Test
    public void testStu3(){
        // 读取配置文件，注入IOC容器
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext01.xml");
        StuInfo stu3 = context.getBean("stu3", StuInfo.class);
        System.out.println(stu3);
    }

（3）、FactoryBean:Spring提供的接口

1、创建FactoryBean的类

2、实现FactoryBean接口

案例：

StuInfoFactoryBeanClass.java

import org.springframework.beans.factory.FactoryBean;
/**
 * 工厂方法：
 *   FactoryBean:Spring提供的接口
 */
public class StuInfoFactoryBeanClass implements FactoryBean<StuInfo> {
    // 传入参数
    private String stuName;
    public void setStuName(String stuName) {
        this.stuName = stuName;
    }
    // factoryBean返回实例时会调用该方法
    @Override
    public StuInfo getObject() throws Exception {
        StuInfo si = new StuInfo();
        si.setStuAddress("江北区");
        si.setStuName(stuName);
        return si;
    }
    // 返回创建的bean的类型
    @Override
    public Class<?> getObjectType() {
        return StuInfo.class;
    }
    // FactoryBean工厂创建的对象是否是单例的  false 非单列     true 单列
    @Override
    public boolean isSingleton() {
        return true;
    }
}

applicationContext01.xml

<!-- 通过FactoryBean配置实例 -->
    <bean id="stu4" class="com.yl.model1.StuInfoFactoryBeanClass">
        <property name="stuName" value="张秋丽"/>
    </bean>

测试

// 测试接口的方式
    @Test
    public void testStu4(){
        // 读取配置文件，注入IOC容器
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext01.xml");
        StuInfo stu4 = context.getBean("stu4", StuInfo.class);
        System.out.println(stu4);
    }

二、AOP:(Acpect Orientend Programming)面向切面编程

在运行时，动态地讲代码切入到类的指定方法的指定位置上的编程思想，称之为面向切面编程。

通知(Advice)：在指定位置执行的增强操作
前置通知(Before):在目标方法执行之前执行的增强操作
后置通知(After):在目标方法执行之后执行的增强操作
返回通知(Returning):方法执行成功之后执行的增强操作
异常通知(Throwing):方法执行失败之后执行的增强操作
环绕通知(Arount):在方法执行之前和之后都会执行的增强操作
链接点(JoinPoint)：可以被织入通知的点
切点(Pointcut)：进行了增强操作的连接点
*切面(Aspect)：包含了切点与通知，确定了要执行的AOP操作在什么地方执行
*织入：将通知织入到对应的连接点的这个操作，称之为织入操作

Spring依赖AspectJ进行AOP的支持

创建一个普通的类作为通知类

导入SpringAOP相关的依赖

	<!-- SpringAOP模块 -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-aop</artifactId>
		<version>${springVersion}</version>
	</dependency>
	<!-- Spring对Aspectj的支持模块 -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-aspects</artifactId>
		<version>${springVersion}</version>
	</dependency>

案例(无参数)：

Calc.java

/**
 * 计算器类
 */
public class Calc {
    public int add(int num1,int num2){
        return num1+num2;
    }
    public int jian(int num1,int num2){
        return num1-num2;
    }
    public int cheng(int num1,int num2){
        return num1*num2;
    }
    public int chu(int num1,int num2){
        return num1/num2;
    }
}

MyCalcAdvice.java

import org.aspectj.lang.ProceedingJoinPoint;
import java.util.Arrays;
public class MyCalcAdvice {
    // 前置
    public void before(){
        System.out.println("--->前置通知执行!");
    }
    // 后置
    public void after(){
        System.out.println("--->后置通知执行！");
    }
    // 返回
    public void returning(){
        System.out.println("--->返回通知执行！");
    }
    // 异常
    public void throwing(){
        System.out.println("--->异常通知执行！");
    }
    // 环绕
    public Object around(ProceedingJoinPoint pjp){
        System.out.println("--->前置环绕"+ Arrays.toString(pjp.getArgs()));
        Object rv = null;
        try {
            rv = pjp.proceed();
            System.out.println("--->环绕返回通知"+rv);
        } catch (Throwable throwable) {
            rv = 0;
            System.out.println("--->环绕通知的异常通知");
        }finally {
            System.out.println("--->环绕通知的后置通知");
        }
        return rv;
    }
}

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

    <!-- 配置一个Bean作为待会被通知的类，目标对象 -->
    <bean id="calc" class="com.yl.model2.Calc"/>
    <!-- 配置一个Bean作为通知类，里面的方法作为通知(前，后，反，异，环)方法 -->
    <bean id="myCalcAdvice" class="com.yl.model2.MyCalcAdvice"/>
    <!--
        <aop:XXX>:Spring的AOP操作依赖的标签，该标签需要导入命名空间
            <aop:config>:AOP配置标签
        SpringAOP:一般用于进行声明式事务的配置
    -->
    <aop:config>
        <!--
            声明切点表达式
                id:切点表达的ID，带通过该属性的值对该切点表达式进行引用
                expression:表达式
                第一个*方法的返回值类型
                第二个*方法的名称
                ..参数列表:任何数量的参数都只需要两个点
        -->
        <aop:pointcut id="pcJisuan" expression="execution(* com.yl.model2.Calc.*(..))"/>
        <!--
            配置切面
                id:切面的名称
                ref:通知类
        -->
        <aop:aspect id="mycalc" ref="myCalcAdvice">
            <!--
                method:通知的具体方法名称
                pointcut:直接声明一个切点表达式，但是就只能在本地使用，不能被其他地方引用，适用于只有单个通知的时候
                pointcut-ref:引用的切点表达式
            -->
            <!--<aop:before method="before" pointcut-ref="pcJisuan"/>
            <aop:after method="after" pointcut-ref="pcJisuan"/>
            <aop:after-returning method="returning" pointcut-ref="pcJisuan"/>
            <aop:after-throwing method="throwing" pointcut-ref="pcJisuan"/>-->
            <aop:around method="around" pointcut-ref="pcJisuan"/>
        </aop:aspect>
    </aop:config>
</beans>

测试

// 测试面向切面编程(基本，不含参数)
    @Test
    public void testCalc1(){
        // 读取配置文件，注入IOC容器
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext02.xml");
        Calc c = context.getBean("calc", Calc.class);
        int num1 = c.add(20,50);
        System.out.println(num1);
        int num2 = c.cheng(20,50);
        System.out.println(num2);
        int num3 = c.chu(100,20);
        System.out.println(num3);
        int num4 = c.jian(50,20);
        System.out.println(num4);
    }

案例（有参数）：

共用Calc.java类

MyCalcAdvice2.java

package com.yl.model2;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import java.util.Arrays;
// 含有参数
public class MyCalcAdvice2{
    //前置
    public void before(JoinPoint jp){
        System.out.println("--->前置通知执行!");
        Object[] args = jp.getArgs();
        System.out.println("**参数列表："+ Arrays.toString(args));
    }
    //后置
    public void after(JoinPoint jp){
        System.out.println("--->后置通知执行！");
    }
    //返回
    public void returning(Object rv){
        System.out.println("--->返回通知执行！");
        System.out.println("**方法的返回值："+rv);
    }
    //异常
    public void throwing(Exception e){
        System.out.println("--->异常通知执行！");
        System.out.println("**异常信息"+e.getMessage());
    }
    /*
     *   ProceedingJoinPoint:
     *       proceed():执行目标方法本身的内容
     * */
    //环绕
    public Object around(ProceedingJoinPoint pjp){
        System.out.println("--->前置环绕"+Arrays.toString(pjp.getArgs()));
        Object rv = null;
        try {
            rv = pjp.proceed();
            System.out.println("--->环绕返回通知"+rv);
        } catch (Throwable throwable) {
            rv = 0;
            System.out.println("--->环绕通知的异常通知");
        }finally {
            System.out.println("--->环绕通知的后置通知");
        }
        return rv;
    }
}

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

    <!-- 含有参数 -->
    <!-- 配置一个Bean作为待会被通知的类，目标对象 -->
    <bean id="calc1" class="com.yl.model2.Calc"/>
    <!-- 配置一个Bean作为通知类，里面的方法作为通知(前，后，反，异，环)方法 -->
    <bean id="myCalcAdvice2" class="com.yl.model2.MyCalcAdvice2"/>
    <!--
        <aop:XXX>:Spring的AOP操作依赖的标签，该标签需要导入命名空间
            <aop:config>:AOP配置标签
        SpringAOP:一般用于进行声明式事务的配置
    -->
    <aop:config>
        <!--
            声明切点表达式
                id:切点表达的ID，带通过该属性的值对该切点表达式进行引用
                expression:表达式
                第一个*方法的返回值类型
                第二个*方法的名称
                ..参数列表:任何数量的参数都只需要两个点
        -->
        <aop:pointcut id="pcJisuan" expression="execution(* com.yl.model2.Calc.*(..))"/>
        <!--
            配置切面
                id:切面的名称
                ref:通知类
        -->
        <aop:aspect id="mycalc" ref="myCalcAdvice2">
            <!--
                method:通知的具体方法名称
                pointcut:直接声明一个切点表达式，但是就只能在本地使用，不能被其他地方引用，适用于只有单个通知的时候
                pointcut-ref:引用的切点表达式
            -->
            <aop:before method="before" pointcut-ref="pcJisuan"/>
            <aop:after method="after" pointcut-ref="pcJisuan"/>
            <aop:after-returning method="returning" pointcut-ref="pcJisuan" returning="rv"/>
            <aop:after-throwing method="throwing" pointcut-ref="pcJisuan" throwing="e"/>
            <aop:around method="around" pointcut-ref="pcJisuan"/>
        </aop:aspect>
    </aop:config>
</beans>

1、Spring AOP（面向切面编程）是什么？

面向切面编程（AOP）和面向对象编程（OOP）类似，也是一种编程模式。Spring AOP 是基于 AOP 编程模式的一个框架，它的使用有效减少了系统间的重复代码，达到了模块间的松耦合目的。

AOP 的全称是“Aspect Oriented Programming”，即面向切面编程，它将业务逻辑的各个部分进行隔离，使开发人员在编写业务逻辑时可以专心于核心业务，从而提高了开发效率。

AOP 采取横向抽取机制，取代了传统纵向继承体系的重复性代码，其应用主要体现在事务处理、日志管理、权限控制、异常处理等方面。

目前最流行的 AOP 框架有两个，分别为 Spring AOP 和 AspectJ。

Spring AOP 使用纯 Java 实现，不需要专门的编译过程和类加载器，在运行期间通过代理方式向目标类植入增强的代码。

AspectJ 是一个基于 Java 语言的 AOP 框架，从 Spring 2.0 开始，Spring AOP 引入了对 AspectJ 的支持。AspectJ 扩展了 Java 语言，提供了一个专门的编译器，在编译时提供横向代码的植入。

为了更好地理解 AOP，就需要对 AOP 的相关术语有一些了解，这些专业术语主要包含 Joinpoint、Pointcut、Advice、Target、Weaving、Proxy 和 Aspect

名称说明
Joinpoint（连接点）指那些被拦截到的点，在 Spring 中，可以被动态代理拦截目标类的方法。
Pointcut（切入点）指要对哪些 Joinpoint 进行拦截，即被拦截的连接点。
Advice（通知）指拦截到 Joinpoint 之后要做的事情，即对切入点增强的内容。
Target（目标）指代理的目标对象。
Weaving（植入）指把增强代码应用到目标上，生成代理对象的过程。
Proxy（代理）指生成的代理对象。
Aspect（切面）切入点和通知的结合。

名称	说明
Joinpoint（连接点）	指那些被拦截到的点，在 Spring 中，可以被动态代理拦截目标类的方法。
Pointcut（切入点）	指要对哪些 Joinpoint 进行拦截，即被拦截的连接点。
Advice（通知）	指拦截到 Joinpoint 之后要做的事情，即对切入点增强的内容。
Target（目标）	指代理的目标对象。
Weaving（植入）	指把增强代码应用到目标上，生成代理对象的过程。
Proxy（代理）	指生成的代理对象。
Aspect（切面）	切入点和通知的结合。

2、Spring 通知类型

Spring 通知的 5 种类型

名称	说明
org.springframework.aop.MethodBeforeAdvice（前置通知）	在方法之前自动执行的通知称为前置通知，可以应用于权限管理等功能。
org.springframework.aop.AfterReturningAdvice（后置通知）	在方法之后自动执行的通知称为后置通知，可以应用于关闭流、上传文件、删除临时文件等功能。
org.aopalliance.intercept.MethodInterceptor（环绕通知）	在方法前后自动执行的通知称为环绕通知，可以应用于日志、事务管理等功能。
org.springframework.aop.ThrowsAdvice（异常通知）	在方法抛出异常时自动执行的通知称为异常通知，可以应用于处理异常记录日志等功能。
org.springframework.aop.IntroductionInterceptor（引介通知）	在目标类中添加一些新的方法和属性，可以应用于修改旧版本程序（增强类）。

3、声明式 Spring AOP

ProxyFactoryBean 的常用属性

属性名称	描述
target	代理的目标对象
proxyInterfaces	代理要实现的接口，如果有多个接口，则可以使用以下格式赋值： …
proxyTargetClass	是否对类代理而不是接口，设置为 true 时，使用 CGLIB 代理
interceptorNames	需要植入目标的 Advice
singleton	返回的代理是否为单例，默认为 true（返回单实例）
optimize	当设置为 true 时，强制使用 CGLIB

案例：

MyAspect.java

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
//需要实现接口，确定哪个通知，及告诉Spring应该执行哪个方法
public class MyAspect implements MethodInterceptor {
    public Object invoke(MethodInvocation mi) throws Throwable {
        System.out.println("方法执行之前");
        // 执行目标方法
        Object obj = mi.proceed();
        System.out.println("方法执行之后");
        return obj;
    }
}

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 id="customerDao" class="com.mengma.dao.CustomerDaoImpl" />
    <!-- 通知 advice -->
    <bean id="myAspect" class="com.mengma.factorybean.MyAspect" />
    <!--生成代理对象 -->
    <bean id="customerDaoProxy"
     class="org.springframework.aop.framework.ProxyFactoryBean">
     <!--代理实现的接口 -->
        <property name="proxyInterfaces" value="com.mengma.dao.CustomerDao" />
        <!--代理的目标对象 -->
        <property name="target" ref="customerDao" />
        <!--用通知增强目标 -->
        <property name="interceptorNames" value="myAspect" />
        <!-- 如何生成代理，true:使用cglib; false :使用jdk动态代理 -->
        <property name="proxyTargetClass" value="true" />
    </bean>
</beans>

FactoryBeanTest .java(测试)

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.mengma.dao.CustomerDao;
public class FactoryBeanTest {
    @Test
    public void test() {
        String xmlPath = "com/mengma/factorybean/applicationContext.xml";
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                xmlPath);
        CustomerDao customerDao = (CustomerDao) applicationContext
                .getBean("customerDaoProxy");
        customerDao.add();
        customerDao.update();
        customerDao.delete();
        customerDao.find();
    }
}

三、Spring对数据库的访问

SpringJDBCTemplate:数据库工具类

导入相关Jar包
jdbc\tx\orm\oxm\jms

		<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spv}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${spv}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${spv}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-oxm</artifactId>
            <version>${spv}</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
            <version>${spv}</version>
        </dependency>
            
        <!--MySQL驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!--连接池-->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>

案例

entity层 UserInfo.java

public class UserInfo {
    private Integer user_id;
    private String user_name;
    private Integer user_age;
    private String user_sex;
    private String user_address;
    public Integer getUser_id() {
        return user_id;
    }
    public void setUser_id(Integer user_id) {
        this.user_id = user_id;
    }
    public String getUser_name() {
        return user_name;
    }
    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }
    public Integer getUser_age() {
        return user_age;
    }
    public void setUser_age(Integer user_age) {
        this.user_age = user_age;
    }
    public String getUser_sex() {
        return user_sex;
    }
    public void setUser_sex(String user_sex) {
        this.user_sex = user_sex;
    }
    public String getUser_address() {
        return user_address;
    }
    public void setUser_address(String user_address) {
        this.user_address = user_address;
    }
    public UserInfo() {
    }
    public UserInfo(Integer user_id, String user_name, Integer user_age, String user_sex, String user_address) {
        this.user_id = user_id;
        this.user_name = user_name;
        this.user_age = user_age;
        this.user_sex = user_sex;
        this.user_address = user_address;
    }
    @Override
    public String toString() {
        return "UserInfo{" +
                "user_id=" + user_id +
                ", user_name='" + user_name + '\'' +
                ", user_age=" + user_age +
                ", user_sex='" + user_sex + '\'' +
                ", user_address='" + user_address + '\'' +
                '}';
    }
}

dao层 UserInfoDao.java

import com.yl.entity.UserInfo;
import org.springframework.jdbc.core.JdbcTemplate;
import java.sql.ResultSet;
public class UserInfoDao {
    /*
     *   JdbcTemplate:Spring对数据库访问的对象
     *       update(被执行的SQL语句，需要参数(可变)):执行增删改的方法
     * */
    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
    // 添加的方法
    public boolean insertUserInfo(UserInfo userInfo){
        String sql = "INSERT INTO user_info VALUES (DEFAULT,?,?,?,?)";
        int row =jdbcTemplate.update(sql,userInfo.getUser_name(),userInfo.getUser_age(),userInfo.getUser_sex(),userInfo.getUser_address());
        return  row>0;
    }
    // 查询的方法
    public UserInfo selectUserInfoByUserId(Integer id){
        String sql = "SELECT * FROM user_info where user_id=?";
        /*
         *   queryForObject
         *      String sqlStr:查询语句
         *      RowMapper:RowMapper的实现类,其中定义了映射规则
         *          mapRow:定义映射规则
         *              ResultSet:结果集对象
         *              rowNum:当前解析到了第几行
         * */
        UserInfo ui = jdbcTemplate.queryForObject(sql, (ResultSet rs, int rowNum)-> {
            System.out.println("当前解析到的行："+rowNum);

            UserInfo userInfo = new UserInfo(rs.getInt(1),rs.getString(2),rs.getInt(3),
                    rs.getString(4),rs.getString(5));
            return userInfo;
        },id);
        return ui;
    }
}

配置文件

db.properties

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.user=root
jdbc.pwd=123456
jdbc.url=jdbc:mysql:///user_db?characterEncoding=UTF-8

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

    <!--引入属性文件-->
    <context:property-placeholder location="db.properties"/>
    <!--创建数据源对象-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driverClass}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.pwd}"/>
    </bean>
    <!--创建SpringJDBCTemplate对数据库进行访问-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 配置dao类  自动注入  -->
    <bean id="userInfoDao" class="com.yl.dao.UserInfoDao" autowire="byType"/>
</beans>

service层 UserInfoService.java

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

public class UserInfoService {

    // 执行添加的 方法
    @Test
    public void testAdd(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserInfoDao bean = context.getBean(UserInfoDao.class);
        boolean bl = bean.insertUserInfo(new UserInfo(null,"小帅比",22,"男","重庆市双碑大桥桥洞"));
        System.out.println(bl?"添加成功":"添加失败");
    }

    // 执行查询的方法
    @Test
    public void testSelect(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserInfoDao bean = context.getBean(UserInfoDao.class);
        UserInfo ui = bean.selectUserInfoByUserId(2);
        System.out.println(ui);
    }
}

jv_xiaobai_yu

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
03.spring的bean的配置,AOP,数据库的访问

03.Springbean的配置,AOP,数据库的访问一、Spring bean的配置1、构造方法的反射案例：StuInfo.java/** * 学生信息的实体信息类 (方式一) */public class StuInfo { private String stuNo; private String stuName; private String stuAddress; private String stuEmail; public String
复制链接

扫一扫