spring框架的基础学习

respectable-face

已于 2022-12-01 22:16:04 修改

阅读量197

点赞数

文章标签： spring 学习 java

于 2022-11-23 23:00:04 首次发布

本文链接：https://blog.csdn.net/m0_56309491/article/details/128008370

版权

1、spring5，bean.xml外部的注入（action层注入service层，service层注入dao层）

类截图

Service层==========UserService.java文件

package com.gtgugu.spring.service;

import com.gtgugu.spring.dao.UserDao;
import com.gtgugu.spring.dao.UserDaoImpl;
//service层
public class UserService {
    //创建userDao属性，并创建set方法
    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void add(){
//调用实现类接口中的方法
        userDao.addUser();
    }
    public void delete(){
        userDao.deleteUser();
    }

}

UserDao.java接口

package com.gtgugu.spring.dao;

public interface UserDao {
   public void update() ;
   void addUser();
   void deleteUser();

}

UserDaoImpl.java实现类

package com.gtgugu.spring.dao;

public class UserDaoImpl implements UserDao{
    public void update() {

    }

    @Override
    public void addUser() {
        System.out.println("addUser开始执行");
        System.out.println("添加用户成功！");
    }

    @Override
    public void deleteUser() {
        System.out.println("deleteUser执行了");
        System.out.println("删除用户成功！");
    }
}

bean1.xml配置文件

采用的是外部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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">


    <!--IOC测试配置文件-->
    <!--外部bean
        id与测试类中的getBean第一个属性对应
          class对应的是service层路径
            name对应的是service层注入的dao层对象
            ref对应的是外部bean的id
-->

   <!-- <bean id="user" class="com.gtgugu.spring.User"></bean>-->
    <bean id="userService" class="com.gtgugu.spring.service.UserService">
        <property name="userDao" ref="userDaoImpl"></property>
    </bean>
    <bean id="userDaoImpl" class="com.gtgugu.spring.dao.UserDaoImpl"></bean>

</beans>

TestSpring5.java测试类

package testdemo;
import com.gtgugu.spring.User;
import com.gtgugu.spring.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class TestSpring5 {

    @Test
    public void testAdd(){
       //加载spring配置文件
        ApplicationContext context=new ClassPathXmlApplicationContext("com/gtgugu/spring/bean1.xml");
        //获取配置文件创建的的对象==============第一个属性和bean.xml文件中id对应
        UserService userService=context.getBean("userService",UserService.class);
//调用service层的方法
                userService.add();
                userService.delete();

    }

}

结果截图：

2、spring5 bean.xml内部注入

类的截图

Dept.java类

package com.gtgugu.spring.bean;
//部门类=====一个部门多个员工
public class Dept {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }

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

Emp.java文件

package com.gtgugu.spring.bean;
//员工类=====一个部门多个员工
public class Emp {
    private String ename;
    private String gender;
    private Dept dept;
    //使用对象注入的方法
    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void add(){
        System.out.println(ename+"::"+gender+"::"+dept);
    }

}

bean3.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="emp" class="com.gtgugu.spring.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="女"></property>
        <!--设置对象类型属性-->
        <property name="dept">
            <bean id="dept" class="com.gtgugu.spring.bean.Dept">
                <property name="dname" value="安保部"></property>
            </bean>
        </property>
    </bean>
</beans>

测试类 TestBean.java文件

package testdemo;
import com.gtgugu.spring.bean.Dept;
import com.gtgugu.spring.bean.Emp;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestBean {
    @Test
    public void testAdd() {
        //加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("com/gtgugu/spring/bean3.xml");
        //获取配置文件创建的的对象==============第一个属性和bean.xml文件中id对应
        Emp emp = context.getBean("emp", Emp.class);
        emp.add();
    }

}

运行结果：

3、级联操作：

方法1：在2的基础上只需要把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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

        <!--内部bean-->
    <bean id="emp" class="com.gtgugu.spring.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="女"></property>
        <!--设置对象类型属性
            级联赋值
        -->
        <property name="dept" ref="dept"></property>
    </bean>
    <bean id="dept" class="com.gtgugu.spring.bean.Dept">
        <property name="dname" value="财务部"></property>
    </bean>
</beans>

方法二：需要在Emp类中声明Dept的get方法（必须）

其次将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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

        <!--内部bean-->
    <bean id="emp" class="com.gtgugu.spring.bean.Emp">
        <!--设置两个普通属性-->
        <property name="ename" value="lucy"></property>
        <property name="gender" value="女"></property>
        <!--设置对象类型属性
            级联赋值
        -->
        <property name="dept" ref="dept"></property>
//与方法1不同
        <property name="dept.dname" value="技术部"></property>
    </bean>
    <bean id="dept" class="com.gtgugu.spring.bean.Dept">
        <property name="dname" value="财务部"></property>
    </bean>
</beans>

4、IOC 操作 Bean 管理（xml 注入集合属性）

1 、注入数组类型属性

2 、注入 List 集合类型属性

3 、注入 Map 集合类型属性

4、注入set集合类型属性

类文件截图

Stu.java实体类，声明属性，创建set方法

package com.gtgugu.spring.collectiontype;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Stu {
    //1、数组类型属性
    private String[] courses;
    //2、list集合类型属性
    private List<String> list;
    //3、map集合类型属性
    private Map<String,String> maps;

    //4、set类型集合属性

    private Set<String> sets;

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

//测试调用的方法===输出值
    public void add(){
        System.out.println(Arrays.toString(courses));//数组不能直接输出
        System.out.println(list);
        System.out.println(maps);
        System.out.println(sets);

    }
}

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


    <!--IOC测试配置文件-->
    <!--外部bean
      id与测试类中的getBean第一个属性对应
        class对应的是service层路径
          name对应的是service层注入的dao层对象
          ref对应的是外部bean的id
-->
  <bean id="stu" class="com.gtgugu.spring.collectiontype.Stu">

      <!--数组集合
            可以使用list也可使用array
      -->
      <property name="courses">
          <list>
              <value>jsp课程</value>
              <value>web课程</value>
          </list>
      </property>

        <!--list集合-->
      <property name="list">
          <list>
              <value>list1集合</value>
              <value>list2集合</value>

          </list>
      </property>

      <!--map集合-->
      <property name="maps">
          <map>
              <entry key="map1集合" value="map1集合"></entry>
              <entry key="map2集合" value="map2集合"></entry>
          </map>
      </property>
        <!--set集合-->
      <property name="sets">
          <set>
              <value>set1集合</value>
              <value>set2集合</value>
          </set>

      </property>

  </bean>

</beans>

测试类代码：testSpring5Demo1.java文件

package com.gtgugu.spring.testDemo;

import com.gtgugu.spring.collectiontype.Stu;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring5Demo1 {

    @Test
    public void test(){
        ApplicationContext context=new ClassPathXmlApplicationContext("com/gtgugu/spring/bean1.xml");
//对应的id值
        Stu stu=context.getBean("stu", Stu.class);
        stu.add();
    }
}

5、在集合里面设置对象类型值

在4的基础上修改Stu.java，bean.xml文件，添加Course.java文件

Course.java文件

package com.gtgugu.spring.collectiontype;
//课程类
public class Course {
    private String cname;//课程名称
    public void setCname(String cname) {
        this.cname = cname;
    }
//有具体的输出值===测试代码控制台
    @Override
    public String toString() {
        return "Course{" +
                "cname='" + cname + '\'' +
                '}';
    }
}

Stu.java文件添加List集合（以Course对象作为属性）

package com.gtgugu.spring.collectiontype;

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Stu {
    //1、数组类型属性
    private String[] courses;
    //2、list集合类型属性
    private List<String> list;
    //3、map集合类型属性
    private Map<String,String> maps;

    //4、set类型集合属性

    private Set<String> sets;
    //学生所学多门课程
    private List<Course> courseList;
    public void setCourseList(List<Course> courseList) {
        this.courseList = courseList;
    }

    public void setSets(Set<String> sets) {
        this.sets = sets;
    }

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }


    public void add(){
        System.out.println(Arrays.toString(courses));
        System.out.println(list);
        System.out.println(maps);
        System.out.println(sets);
        System.out.println(courseList);

    }
}

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


    <!--IOC测试配置文件-->
    <!--外部bean
      id与测试类中的getBean第一个属性对应
        class对应的是service层路径
          name对应的是service层注入的dao层对象
          ref对应的是外部bean的id
-->
  <bean id="stu" class="com.gtgugu.spring.collectiontype.Stu">

      <!--数组集合
            可以使用list也可使用array
      -->
      <property name="courses">
          <list>
              <value>jsp课程</value>
              <value>web课程</value>
          </list>
      </property>

        <!--list集合-->
      <property name="list">
          <list>
              <value>list1集合</value>
              <value>list2集合</value>

          </list>
      </property>

      <!--map集合-->
      <property name="maps">
          <map>
              <entry key="map1集合" value="map1集合"></entry>
              <entry key="map2集合" value="map2集合"></entry>
          </map>
      </property>
        <!--set集合-->
      <property name="sets">
          <set>
              <value>set1集合</value>
              <value>set2集合</value>
          </set>
      </property>


      <!--list里面存放对象-->
      <property name="courseList">
          <list>
              <ref bean="course1"></ref>
              <ref bean="course2"></ref>
          </list>

      </property>

  </bean>
    <bean id="course1" class="com.gtgugu.spring.collectiontype.Course">
        <property name="cname" value="spring5基础学习"></property>
    </bean>
    <bean id="course2" class="com.gtgugu.spring.collectiontype.Course">
        <property name="cname" value="spring5进阶学习"></property>
    </bean>
</beans>

结果截图

5、2把集合注入部分提取出来

Book.java文件

package com.gtgugu.spring.collectiontype;

import java.util.List;

public class Book {
    private List<String> list;

    public void setList(List<String> list) {
        this.list = list;
    }
    public void test(){
        System.out.println(list);
    }
}

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

        <!--在spring配置文件中引入名称空间util-->
        <!--1 提取 list 集合类型属性注入-->
        <util:list id="listbook">
                <value>jsp程序设计</value>
                <value>java程序设计</value>
                <value>web框架技术</value>
        </util:list>

        <!--2 提取 list 集合类型属性注入使用
                property中的name与实体类中定义的对象属性对应
                ref与提取出来的util的id值对应

        -->
        <bean id="book" class="com.gtgugu.spring.collectiontype.Book">
                <property name="list" ref="listbook"></property>

        </bean>

</beans>

测试类代码：

@Test
    public void test2(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean2.xml");
        Book book=context.getBean("book",Book.class);
        book.test();
    }

结果截图

6、配置外部属性注入

6、1直接配置数据库连接池

<!--数据库连接池的配置-->
        <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/userDb"></property>
                <property name="username" value="root"></property>
                <property name="password" value="root"></property>
        </bean>

6、2引入外部属性文件配置数据库连接池

编写的jdbc.properties文件

prop.driverClass=com.mysql.jdbc.Driver
prop.userName=root
prop.password=root
prop.url=jdbc:mysql://localhost:3306/userDb

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

">


        <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>


        <!--数据库连接池的配置-->
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
                <property name="driverClassName" value="${prop.driverClass}"></property>
                <property name="url" value="${prop.userName}"></property>
                <property name="username" value="${prop.password}"></property>
                <property name="password" value="${prop.url}"></property>
        </bean>



</beans>

7、IOC操作bean管理（基于注释）

基于注解方式实现对象创建

第一步：引入依赖

第二步：开启组件扫描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">


         <!--开启组件扫描
            方法1 如果扫描多个包，多个包使用逗号隔开
             方法2 扫描包上层目录
          -->

    <context:component-scan base-package="com.gtgugu.spring.Service"></context:component-scan>


</beans>

第三步：创建类，在类上添加创建对象注解UserService.java文件

package com.gtgugu.spring.Service;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

//在注解里面 value 属性值可以省略不写，
//默认值是类名称，首字母小写
//UserService -- userService
//@Component(value = "userService") //对应的是bean里面的id值<bean id="userService" class=".."/>
@Service
public class UserService {
    public void add() {
        System.out.println("service add.......");
    }
}

测试类：

package com.gtgugu.spring.testDemo;

import com.gtgugu.spring.Service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestSpring5Demo1 {

    @Test
    public void test(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService=context.getBean("userService",UserService.class);
        userService.add();
    }
}

8、AOP底层原理

代码增强逻辑：

第一种有接口情况，使用 JDK 动态代理

⚫ 创建接口实现类代理对象，增强类的方法

1 、使用 JDK 动态代理，使用 Proxy 类里面的方法创建代理对象

UserDao.java代码

package com.gtgugu.spring.ProxBean;

public interface UserDao {
    public int add(int a,int b);
    public String update(String id);
}

UserDaoImpl.java代码

package com.gtgugu.spring.ProxBean;

public class UserDaoImpl implements UserDao{
    @Override
    public int add(int a, int b) {
        return a+b;
    }

    @Override
    public String update(String id) {
        return id;
    }
}

UserDaoProx.java代码

package com.gtgugu.spring.ProxBean.Proxy;

import com.gtgugu.spring.ProxBean.UserDao;
import com.gtgugu.spring.ProxBean.UserDaoImpl;

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

public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类代理对象
        Class[] interfaces = {UserDao.class};
// Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces,new InvocationHandler() {
// @Override
// public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
// return null;
// }
// });
                UserDaoImpl userDao = new UserDaoImpl();
                //调用方法处理机制
                UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
                int result = dao.add(1, 2);
                System.out.println("result:"+result);
            }
        }
//创建代理对象代码
        class UserDaoProxy implements InvocationHandler {
            //1 把创建的是谁的代理对象，把谁传递过来
            //有参数构造传递
            private Object obj;
            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);
                //方法之后
                System.out.println("方法之后执行...."+obj);
                return res;
            }
}

JDKProx.java文件

package com.gtgugu.spring.ProxBean.Proxy;

import com.gtgugu.spring.ProxBean.UserDao;
import com.gtgugu.spring.ProxBean.UserDaoImpl;

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

public class JDKProxy {
    public static void main(String[] args) {
        //创建接口实现类代理对象
        Class[] interfaces = {UserDao.class};
// Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces,new InvocationHandler() {
// @Override
// public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
// return null;
// }
// });
                UserDaoImpl userDao = new UserDaoImpl();
                //调用方法处理机制
                UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
                int result = dao.add(1, 2);
                System.out.println("result:"+result);
            }
        }
//创建代理对象代码
        class UserDaoProxy implements InvocationHandler {
            //1 把创建的是谁的代理对象，把谁传递过来
            //有参数构造传递
            private Object obj;
            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);
                //方法之后
                System.out.println("方法之后执行...."+obj);
                return res;
            }
}

9、JdbcTemplate

（ 1 ） Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作

引入的jar包

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"
       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="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="jdbc:mysql:///ssh_crm" />
        <property name="username" value="root" />
        <property name="password" value="123456" />
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    </bean>
<!--配置jdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入dataSource-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 组件扫描 -->
    <context:component-scan base-package="com.gtgugu.spring"></context:component-scan>

</beans>

实体类User.java文件

package com.gtgugu.spring.entity;

public class User {

    private String userId;
    private String username;
    private String ustatus;

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getUstatus() {
        return ustatus;
    }

    public void setUstatus(String ustatus) {
        this.ustatus = ustatus;
    }
}

UserService.java文件

package com.gtgugu.spring.Service;

import com.gtgugu.spring.dao.UserDao;
import com.gtgugu.spring.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Autowired
    private UserDao userDao;//注入dao层
    public void update(User user){
        userDao.add(user);
    }


}

UserDao.java文件

package com.gtgugu.spring.dao;

import com.gtgugu.spring.entity.User;


public interface UserDao {
    void add(User user);
}

UserDaoImpl.java文件

package com.gtgugu.spring.dao;

import com.gtgugu.spring.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class UserDaoImpl implements UserDao{
    @Autowired
    private JdbcTemplate jdbcTemplate;//注入JdbcTemplate
    public void add(User user) {
        //1 创建 sql 语句
        String sql = "insert into t_user values(?,?,?)";
        //2 调用方法实现
        Object[] args = {user.getUserId(), user.getUsername(),user.getUstatus()};
        int update = jdbcTemplate.update(sql,args);
    }




//若是查询数据库中信息条数使用的方法queryForObject（）

/*   @Override
    public int count() {
        String sql="select count(*) from t_user";
        int count=jdbcTemplate.queryForObject(sql,Integer.class);
        return count;
    }


*/

}

测试类TestUser.java文件

package com.gtgugu.spring.TestUser;

import com.gtgugu.spring.Service.UserService;
import com.gtgugu.spring.entity.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestUser {
   @Test
    public void test(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService=context.getBean("userService",UserService.class);
        User user=new User();
        user.setUserId("1");
        user.setUsername("小白");
        user.setUstatus("9");
        userService.update(user);
    }

}

数据库操作结果;