手撕Spring框架-CSDN博客

本文链接：https://blog.csdn.net/qq_45605535/article/details/115557557

文章目录

IOC

传统的方法赋值

bean1.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注入的方式-->
    <bean id="dept" class="IOC.autoware.Dept">
        <property name="empt" ref="empt"></property>
    </bean>
    <!--    上面使用外部进行创建的方式进行包含-->
    <bean id="empt" class="IOC.autoware.Empt"></bean>
</beans>

dept类

package IOC.autoware;

public class Dept {
    public Empt empt;

    //该方法特别重要，用于属性注入，bean必备
    public Empt getEmpt() {
        return empt;
    }

    public void setEmpt(Empt empt) {
        this.empt = empt;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "empt=" + empt +
                '}';
    }
}

empt类

package IOC.autoware;

public class Empt {
    public String name="cong";

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Empt{" +
                "name='" + name + '\'' +
                '}';
    }
}

使用自动装配的方法进行赋值

自动装配的方法一之byName

<?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">
    <!--    需要注意的一点就是empt的id必须和Dept类中声明的变量一致，如果不一致就创建不了这个对象-->
    <bean id="dept" class="IOC.autoware.Dept" autowire="byName"/>
    <bean id="empt" class="IOC.autoware.Empt"/>
</beans>

自动装配方法二之byType

<?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">
    <!--    需要注意的一点就是empt的id必须和Dept类中声明的变量一致，如果不一致就创建不了这个对象-->
    <!--    <bean id="dept" class="IOC.autoware.Dept" autowire="byName"/>-->
    <!--    使用type类型进行查找缺点就是只能声明一个-->
    <bean id="dept" class="IOC.autoware.Dept" autowire="byType"/>
    <bean id="empt" class="IOC.autoware.Empt"/>
</beans>

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/maindemo"></property>
        <property name="username" value="root"></property>
        <property name="password" value="5201314Lc?"></property>
    </bean>
</beans>

调用创建的datasource对象

public void test3() {
    //引入配置文件并创建上下文对象
    ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
    //从配置文件中获取的上下文对象查找对应的deot
    DruidDataSource jdbc1 = context.getBean("datasource",com.alibaba.druid.pool.DruidDataSource.class);
    System.out.println(jdbc1);
}

使用配置文件的方式连接数据库

bean.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命名空间-->
<!--    第二步引入外部配置文件-->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
<!--    第三步配置连接池-->
    <bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${props.driverClassName}"></property>
        <property name="url" value="${props.url}"></property>
        <property name="username" value="${props.name}"></property>
        <property name="password" value="${props.password}"></property>
    </bean>
</beans>

jdbc.properties

props.driverClassName = com.mysql.jdbc.Driver
props.url = jdbc:mysql://localhost:3306/maindemo
props.name = root
props.password = 5201314Lc?

基于注解方式的IOC操作之Bean管理

什么是注解

注解就是代码特殊标记，格式：@注解名称（属性名称=属性值，属性名称=属性值）
使用注解，注解作用在类上面，方法上面，属性上面
使用注解目的，简化xml配置

对Bean管理中创建对象提供注解

@Component @Service @Controller @Repository

上面四个注解功能是一样的，都可以用来创建bean实例

bean.xml

今年是2021/4/8，最新版本的spring仍然不能适应jdk15，所以我选择将jdk版本降为jdk11

<?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:component-scan base-package="com.lincong.pro"></context:component-scan>
</beans>

作为Bean的类前面加注解用于对象的创建

package com.lincong.pro;

import org.springframework.stereotype.Component;

@Component(value = "empService")
public class EmpService {
    public void DoService() {
        System.out.println("I'm your father!");
    }
}

测试组件扫描的方式创建对象的便捷之处（就是将包注解引入之后就可以没必要class写那么长了）

package test;

import com.lincong.pro.EmpService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class mtest {
    @Test
    public void test1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        //从配置文件中获取的上下文对象查找对应的deot
        EmpService service = context.getBean("empService",EmpService.class);
        service.DoService();
    }
}

组件包扫描之控制组件扫描内容的做法

正常情况下use-default-filters是为true的，当我们设置为false的时候就可以根据注解的类型来决定是否进行扫描。

<?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:component-scan base-package="com.lincong.pro" use-default-filters="false">
              <context:include-filter type="annotation" expression="org.springframework.stereotype.Component"/>
              <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"/>
       </context:component-scan>
</beans>

实现属性的注入

属性的自动注入,像这些就不需要显示声明get和set方法，逐步优化了代码。

package com.lincong.pro.dao;

import org.springframework.stereotype.Repository;
/*该接口实现UserDao类，同时将其归属为Repository*/
@Repository
public class UserDaoImpl implements UserDao {
    @Override
    public void DoService() {
        System.out.println("I'm your grandfather!");
    }
}

下方实现了属性的自动装配，比如这个userDao需要进行new分配堆区空间，完全可以使用自动装配让其自己去声明和赋值空间

package com.lincong.pro.service;

import com.lincong.pro.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service(value = "userDaoService")
public class UserDaoService {
    //    可以实现一种多态的形式
    @Autowired
    private UserDao userDao;

    public void Do() {
        System.out.println("I'm your grandmother!");
        userDao.DoService();
    }

}

Test函数的调用

@Test
public void test3(){
    ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
    //从配置文件中获取的上下文对象查找对应的deot
    UserDaoService service = context.getBean("userDaoService", UserDaoService.class);
    service.Do();
}

属性自动注入之指定某个实现类进行赋值（用在类似于像UserDao有很多个实现类的情况，如果简简单单使用@Autowired进行初始化就会不知道该使用谁来进行初始化），这个时候就需要配合使用Qualifier标签进行使用

package com.lincong.pro.service;

import com.lincong.pro.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service(value = "userDaoService")
public class UserDaoService {
    //    Autowired用于指定类型，Qualifier用于指定名字
    @Autowired
    @Qualifier(value = "mychild1")
    private UserDao userDao;

    public void Do() {
        System.out.println("I'm your grandmother!");
        userDao.DoService();
    }

}

@Resource替代@Qualifier和@Autowired

对于下面这个属性的注入你需要引入annotation-api.jar

package com.lincong.pro.service;

import com.lincong.pro.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service(value = "userDaoService")
public class UserDaoService {
    //    可以实现一种多态的形式
    @Autowired
    @Qualifier(value = "mychild1")
    private UserDao userDao;

    //其实从这里我们可以注意到的一点就是@Resource并不是spring框架的东西，这个是java扩展包的一些东西
    //如果单单使用@Resource就只是相当于指定类型的作用进行初始化，带参数就指定对应的类进行创建
    @Resource(name = "mychild1")
    private UserDao userDao1;

    public void Do() {
        System.out.println("I'm your grandmother!");
        userDao.DoService();
        userDao1.DoService();
    }
}

普通属性的注入

//像这种注入，我们直接在上面赋值即可，特别方便
@Value(value = "lincong")
private String name;

纯注解的开发（配置类的方式）

使用配置类代替xml配置文件

package com.lincong.pro;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
//将类作为配置文件
@Configuration
//配置组件扫描的路径
@ComponentScan(basePackages = {"com.lincong.pro"})
public class Configure {
}

@Test
public void test4(){
    //注意，这个配置类最好写在主包下才可进行导入
    ApplicationContext context = new AnnotationConfigApplicationContext(Configure.class);
    //从配置文件中获取的上下文对象查找对应的deot
    UserDaoService service = context.getBean("userDaoService", UserDaoService.class);
    service.Do();
}

AOP

概念

AOP，面向切面编程，对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间得耦合度。通俗来说不修改源代码的方式添加新功能，实现模块与模块之间独立性。

AOP术语

连接点：类中哪些方法可以增强，这些方法就称为连接点
切入点：实际被真正增强的方法被称为切入点
通知（增强）：实际增强的逻辑部分称为通知，通知有多种类型。
- 前置通知
- 后置通知
- 环绕通知
- 异常通知
- 最终通知：finally
切面：是动作，把通知应用到切入点过程

AOP操作（准备）

Spring框架一般都是基于AspectJ实现AOP操作，但是AspectJ不是spring的组成部分，是一个独立的AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作
基于AspectJ实现AOP操作（1.基于xml配置文件实现 2.基于注解方式实现）
对于AspectJ需要引入如下jar包

spring-aop-5.2.3.RELEASE.jar spring-aspects-5.2.3.RELEASE.jar com.springsource.net.sf.cglib-2.2.0.jar com.springsource.org.aopalliance-1.0.0.jar com.springsource.org.aspectj.weaver-1.7.2.RELEASE.jar
切入点表达式

（1）切入点表达式作用：确切的定位到对哪个类中具体的方法进行增强操作

（2）语法结构形式

execution([权限修饰符] [返回类型] [类全路径] [方法名称] [参数列表])

举例用法就是execution(* com.lincongpro.add(xx,xx))，其中的*代表的是任意类型的修饰符

对类中的所有方法进行增强

execution(* com.lincongpro.* (…))

对com包下的所有类进行增强

execution(* com.*.* (…))

AOP操作（AspectJ注解方式-工作常用）

aop.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"
       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/context http://www.springframework.org/schema/context/spring-context.xsd
                          http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--    这里需要注意一点的就是需要引入context和aop两个命名空间-->
    <!--    开启注解扫描-->
    <context:component-scan base-package="pro.xmlAOC"></context:component-scan>
    <!--    开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
</beans>

UserDaoProxy增强类

package pro.xmlAOC;

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

//被增强的类，下面这两个语句使用之后才能使用AOC的功能
@Component
@Aspect
public class UserProxy {
//    增强的代理类中应该写了很多很多用于处理增强事务的方法
    //前置通知
    @Before(value = "execution(* pro.xmlAOC.AOC2.UserDaoImpl.add(..))")
    public void before() {
        System.out.println("before....");
    }

    @After(value = "execution(* pro.xmlAOC.AOC2.UserDaoImpl.add(..))")
    public void after() {
        System.out.println("after....");
    }

    @AfterReturning(value = "execution(* pro.xmlAOC.AOC2.UserDaoImpl.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning....");
    }

    @AfterThrowing(value = "execution(* pro.xmlAOC.AOC2.UserDaoImpl.add(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing....");
    }
}

UserDaoImpl需要增强的类

package pro.xmlAOC.AOC2;

import org.springframework.stereotype.Component;

@Component(value = "myUserDao")
public class UserDaoImpl implements UserDao {
    @Override
    public int add(int a, int b) {
        return a+b;
    }

    @Override
    public String SetName(String name) {
        return name;
    }
}

测试函数

@Test
public void test5(){
    //注意，这个配置类最好写在主包下才可进行导入
    ApplicationContext context = new ClassPathXmlApplicationContext("aoc.xml");
    //从配置文件中获取的上下文对象查找对应的deot
    UserDaoImpl service = context.getBean("myUserDao", UserDaoImpl.class);
    service.add(2,2);
}

相同切入点的抽取

package pro.xmlAOC;

import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

//被增强的类
@Component
@Aspect
public class UserProxy {
//    增强的代理类中应该写了很多很多用于处理增强事务的方法
    //对于同一个类进行增强的抽取方法
    @Pointcut(value = "execution(* pro.xmlAOC.AOC2.UserDaoImpl.add(..))")
    public void pointdemo() {

    }

    //前置通知
    @Before(value = "pointdemo()")
    public void before() {
        System.out.println("before....");
    }

    @After(value = "pointdemo()")
    public void after() {

        System.out.println("after....");
    }

    @AfterReturning(value = "pointdemo()")
    public void afterReturning() {

        System.out.println("afterReturning....");
    }
    //下面的注解主要针对于源代码有错误的情况所做的操作
    @AfterThrowing(value = "pointdemo()")
    public void afterThrowing() {
        System.out.println("afterThrowing....");
    }
}

多个增强代理类执行优先级问题

@Order设置的数字越小越优先执行

PersonProxy类的before增强

@Order(1)
public void before() {
    System.out.println("Person before....");
}

UserProxy的before增强

@Before(value = "pointdemo()")
@Order(2)
public void before() {
    System.out.println("before....");
}

配置类代理xml的写法

package config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

//第一步将这个类设置为配置类
@Configuration
//第二步开启组件扫描
@ComponentScan(value = "pro.xmlAOC")
//第三步开启AspectJ自动代理，默认为False
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAOP {
}

AOP操作（配置文件的方式）

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"
       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/context http://www.springframework.org/schema/context/spring-context.xsd
                          http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <bean id="Buy" class="aopxml.Buy"></bean>
    <bean id="ProxyBuy" class="aopxml.ProxyBuy"></bean>
    <!--    下面的这个语句就相当于@Aspect作用-->
    <aop:config>
        <!--        配置切入点-->
        <aop:pointcut id="my_pointcut_proxy" expression="execution(* aopxml.Buy.buy(..))"/>
        <!--        指明代理类-->
        <aop:aspect ref="ProxyBuy">
            <aop:before method="before" pointcut-ref="my_pointcut_proxy"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

Java类

package aopxml;

public class Buy {
    public void buy() {
        System.out.println("buy.......");
    }
}

package aopxml;

public class ProxyBuy {
    public void before() {
        System.out.println("Proxy before .......");
    }
}

@Test
public void test6(){
    //注意，这个配置类最好写在主包下才可进行导入
    ApplicationContext context = new ClassPathXmlApplicationContext("aopxml.xml");
    //从配置文件中获取的上下文对象查找对应的deot
    Buy buy = context.getBean("Buy", Buy.class);
    buy.buy();
}

AOP底层原理

AOP底层使用动态代理

有两种情况动态代理，第一种有接口情况（JDK动态代理），第二种没有接口情况（CGLIB动态代理）。

interface UserDao {
	public void login();
}
class UserDaoImpl implements UserDao {
	public void login() {
	    //登录实现过程
	}
}
//而对于这种情况JDK实现动态代理的方式就是创建UserDao接口实现类代理对象

class User {
	public void add() {
		...
	}
}
class Person extends User {
    public void add() {
        super.add();
        //增强逻辑
    }
}
//对于这种无接口的情况就是创建当前子类的代理对象，CGLIB动态代理

JDK动态代理代码

package com.AOC;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

//使用Proxy类创建接口代理对象
public class JDKProxy {
    public static void main(String[] args) {
        //类接口的传递
        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDao = new UserDaoImpl();
        //使用强制转化将返回的Object对象转化为接口对象
        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(),interfaces,new UserDaoProxy(userDao));
        //然后利用我们的接口对象进行实现类的增强函数的调用
        System.out.println(dao.add(1,2));
        System.out.println(dao.SetName("ss"));
    }
}
//创建代理对象代码
class UserDaoProxy implements InvocationHandler {

    //创建的是谁的代理对象就把谁传递进来
    private Object obj;//当然这里完全可以使用UserDao的方式进行传递，但是相对来说肯定是Object类型更实用
    public UserDaoProxy(Object obj) {
        this.obj = obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //方法执行之前
        System.out.println("方法执行之前......"+method.getName()+" :传递的参数....."+ Arrays.toString(args));
        //其实哈实质上应该就是当我们执行接口的方法的时候就会触发这个增强的一个逻辑函数而不再是之前的那个简单的非优化函数
        //被增强的方法执行(就之前没有改变的代码，所以说我只是在之前的代码之上增加了我的实现逻辑部分)
        Object res = method.invoke(obj,args);
        if(method.getName().equals("add"))
        {
            System.out.println("add函数执行了！");
        }else {
            System.out.println("Name函数执行了！");
        }
        //方法之后
        System.out.println("方法执行之后...."+obj);
        return res;
    }
}

JDBCTemplate

准备

需要的jar包：spring-jdbc spring-orm spring-tx mysql-connector-java druid

jdbc.properties配置数据库连接池

props.url = jdbc:mysql://localhost:3306/maindemo
props.username = root
props.password = 5201314Lc?
props.driverClassName = com.mysql.cj.jdbc.Driver

jdbcTemplate.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"
       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/context http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--    因为我们引入了mysql的jdbc连接jar包，现在只需要创建其对象即可-->
    <!--    第二步引入外部配置文件-->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="username" value="${props.username}"></property>
        <property name="password" value="${props.password}"></property>
        <property name="url" value="${props.url}"></property>
        <property name="driverClassName" value="${props.driverClassName}"></property>
    </bean>
    <!--    配置jdbctmeplate对象以便注入-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--        观察jdbcTemplate源码我们可以知道其是通过set方法进行注入，所以使用properties属性即可-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--    接下来配置自动注入,将jdbcTemplate注入到dao中，然后将dao注入到service中-->
    <context:component-scan base-package="jdbcTemplate"></context:component-scan>
</beans>

myDao中自动装配jdbcTemplate对象

package jdbcTemplate.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

//自动注入在xml中创建的对象
@Repository
public class myDao1 {
    //设置属性的自动注入
    @Autowired
    private JdbcTemplate jdbcTemplate;

    public void updateTable(int id, String username, String ustatus) {
        //该方法实现的是表的更新，即使用sql语句将记录插入表中
        String sql = "insert into t_user (user_id,username,ustatus) values(?,?,?)";
        Object[] args = {id, username, ustatus};//Object...形式为多值可变参数
        if(jdbcTemplate != null)
        {
            //返回的是影响的行数
            int effect_line = jdbcTemplate.update(sql,args);
        }
    }

    public void modifyTable(int id,String username,String ustatus) {
        //该方法的作用是根据id修改数据库中的表
        String sql = "update t_user set username=?,ustatus=? where user_id=?";
        Object[] args = {username,ustatus,id};
        jdbcTemplate.update(sql,args);
    }

    public void deleteTable(int id) {
        String sql = "delete from t_user where user_id=?";
        Object[] args = {id};
        jdbcTemplate.update(sql,args);
    }
}

myService中自动装配myDao对象

package jdbcTemplate.service;

import jdbcTemplate.dao.myDao1;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

//配置自动注入
@Component(value = "myService1")
public class myService1 {
    @Autowired
    private myDao1 myDao;
    public void Insert(int id, String username, String ustatus) {
        myDao.updateTable(id,username,ustatus);
        System.out.println("数据库操作成功！");
    }
    public void Modify(int id, String username, String ustatus) {
        myDao.modifyTable(id,username,ustatus);
    }
    public void Delete(int id) {
        myDao.deleteTable(id);
    }
}

JDBCTemplate查询

JDBCTemplate查询返回值

//实现表的查询（普通类型的查询结果）
public int queryNumber() {
    String sql = "select count(*) from t_user";
    Integer count = jdbcTemplate.queryForObject(sql,Integer.class);
    return count;
}

JDBC查询返回对象

queryForObject(String sql,RowMapper rowMapper, Object… args)

第一个参数就是我们的查询sql语句
第二个参数就是RowMapper接口的实现类，BeanPropertyRowMappper(Book.class)英文意思就是将查询到的一行返回为一个对象
第三个参数就是sql的语句值

//实现表的查询（返回一个对象）
public User queryUser(int id) {
    String sql = "select * from t_user where user_id=?";
    User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class),id);
    //将查询到的结果强转为一个user对象
    return user;
}

JDBCTemplate查询返回集合

query(String sql,RowMapper rowMapper, Object… args)

//实现表的查询（返回一个对象列表）
public List<User> queryUsers() {
    String sql = "select * from t_user";
    List<User> users = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
    //将查询到的结果强转为一个user对象
    return users;
}

JDBCTemplate批量操作

batchUpdate(sql,batchArgs)

//传入的是一个以参数数组为基本元素的列表
public void BatchAdd(List<Object[]> args) {
    String sql = "insert into t_user (user_id,username,ustatus) values(?,?,?)";
    jdbcTemplate.batchUpdate(sql,args);
}

//传入的是一个以参数数组为基本元素的列表
public void BatchDelete(List<Object[]> args) {
    String sql = "delete from t_user where user_id=?";
    jdbcTemplate.batchUpdate(sql,args);
}