JavaWeb：（练习）十六、Spring学习练习二

最新推荐文章于 2022-04-06 20:05:05 发布
最新推荐文章于 2022-04-06 20:05:05 发布
阅读量380 收藏
点赞数 1
分类专栏： JavaWeb练习 文章标签： spring 学习 java 后端 maven
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44125436/article/details/123389984
版权

JavaWeb：（练习）十六、Spring学习练习二

JavaWeb：（练习）十六、Spring学习练习二

一、学习目标

​ 初次接触Spring框架，学习了Spring的基础，基本了解了Spring的作用和优缺点。

​ 搭建了第一个Spring项目，导入Spring配置文件，学习并练习了IOC控制反转，并且进行Spring Bean管理，以xml配置方式和注解方式分别实现。并且练习了Spring JDBC。由此完成了spring练习一

​ JavaWeb：（练习）十五、Spring学习练习一

​ 在练习一的基础上，学习并练习了Spring AOP、Spring事务管理等。以下是在练习一的基础上，所改变的练习代码。

​ 注：关于UserDao改为接口，是因为在学习测试Spring集成MyBatis学习，其中包含错误。

二、dao包

1、BankDao

package com.ffyc.spring1.dao;

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

@Repository(value = "bankDao")
public class BankDao {

    @Autowired
    JdbcTemplate jdbcTemplate;

    public void addMoney() {
        jdbcTemplate.update("update bank set bank_money = bank_money + 500 where bank_account = 222");
    }

    public void reduceMoney() {
        jdbcTemplate.update("update bank set bank_money = bank_money - 500 where bank_account = 111");
    }
}

2、StudentDao

package com.ffyc.spring1.dao;

import com.ffyc.spring1.model.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

@Repository(value = "studentDao")
public class StudentDao {

    @Autowired
    JdbcTemplate jdbcTemplate;

    public void save() {

        /*
        JdbcTemplate 中常用的方法
            execute：无返回值，可执行 ddl，增删改语句
            update：执行新增、修改、删除语句；
            queryForXXX：执行查询相关语句；
         */

        List<Student> students = jdbcTemplate.query("select * from student where student_gender = ?", new RowMapper<Student>() {
            @Override
            public Student mapRow(ResultSet resultSet, int i) throws SQLException {
                Student student = new Student();
                student.setStudentId(resultSet.getInt("student_id"));
                student.setStudentNumber(resultSet.getString("student_number"));
                student.setStudentName(resultSet.getString("student_name"));
                return student;
            }
        }, "男");
        System.out.println(students);
    }
}

3、UserDao

package com.ffyc.spring1.dao;

import com.ffyc.spring1.model.User;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository(value = "userDao")
public interface UserDao {
    /*public void save() {
        System.out.println("执行了UserDao的save");
    }*/

    public List<User> findAllUsers();
}

三、model包

1、Bank

package com.ffyc.spring1.model;

import org.springframework.stereotype.Component;

@Component(value = "bank")
public class Bank {
    private Integer bankId;
    private String bankAccount;
    private Integer bankMoney;

    public Bank() {
    }

    public Bank(Integer bankId, String bankAccount, Integer bankMoney) {
        this.bankId = bankId;
        this.bankAccount = bankAccount;
        this.bankMoney = bankMoney;
    }

    public Integer getBankId() {
        return bankId;
    }

    public void setBankId(Integer bankId) {
        this.bankId = bankId;
    }

    public String getBankAccount() {
        return bankAccount;
    }

    public void setBankAccount(String bankAccount) {
        this.bankAccount = bankAccount;
    }

    public Integer getBankMoney() {
        return bankMoney;
    }

    public void setBankMoney(Integer bankMoney) {
        this.bankMoney = bankMoney;
    }

    @Override
    public String toString() {
        return "Bank{" +
                "bankId=" + bankId +
                ", bankAccount='" + bankAccount + '\'' +
                ", bankMoney=" + bankMoney +
                '}';
    }
}

2、Student

package com.ffyc.spring1.model;

import org.springframework.stereotype.Component;

@Component(value = "student")
public class Student {
    private Integer studentId;
    private String studentNumber;
    private String studentName;

    public Student() {
    }

    public Student(Integer studentId, String studentNumber, String studentName) {
        this.studentId = studentId;
        this.studentNumber = studentNumber;
        this.studentName = studentName;
    }

    public Integer getStudentId() {
        return studentId;
    }

    public void setStudentId(Integer studentId) {
        this.studentId = studentId;
    }

    public String getStudentNumber() {
        return studentNumber;
    }

    public void setStudentNumber(String studentNumber) {
        this.studentNumber = studentNumber;
    }

    public String getStudentName() {
        return studentName;
    }

    public void setStudentName(String studentName) {
        this.studentName = studentName;
    }

    @Override
    public String toString() {
        return "Student{" +
                "studentId=" + studentId +
                ", studentNumber='" + studentNumber + '\'' +
                ", studentName='" + studentName + '\'' +
                '}';
    }
}

3、User

package com.ffyc.spring1.model;

import org.springframework.stereotype.Component;

@Component(value = "user")
public class User {

    private Integer userId;
    private String userAccount;
    private String userPassword;

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

    public User(Integer userId, String userAccount, String userPassword) {
        System.out.println("有参");
        this.userId = userId;
        this.userAccount = userAccount;
        this.userPassword = userPassword;
    }

    public Integer getUserId() {
        return userId;
    }

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

    public String getUserAccount() {
        return userAccount;
    }

    public void setUserAccount(String userAccount) {
        this.userAccount = userAccount;
    }

    public String getUserPassword() {
        return userPassword;
    }

    public void setUserPassword(String userPassword) {
        this.userPassword = userPassword;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", userAccount='" + userAccount + '\'' +
                ", userPassword='" + userPassword + '\'' +
                '}';
    }

}

四、service包

1、BankService

package com.ffyc.spring1.service;

import com.ffyc.spring1.dao.BankDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service(value = "bankService")
@Transactional
public class BankService {

    @Autowired
    BankDao bankDao;

    public void transMoney() {
        System.out.println("执行了转账操作！");
        bankDao.reduceMoney();
        bankDao.addMoney();
        System.out.println("转账操作执行完成！");
    }

    public BankService() {
    }

    public BankService(BankDao bankDao) {
        this.bankDao = bankDao;
    }

    public BankDao getBankDao() {
        return bankDao;
    }

    public void setBankDao(BankDao bankDao) {
        this.bankDao = bankDao;
    }
}

2、StudentService

package com.ffyc.spring1.service;

import com.ffyc.spring1.dao.StudentDao;
import com.ffyc.spring1.model.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.xml.ws.soap.Addressing;

@Service(value = "studentService")
public class StudentService {
    /*@Autowired
    StudentDao studentDao;*/

    /*@Autowired
    @Qualifier(value = "studentDao")
    StudentDao studentDao;*/

    /*@Resource
    StudentDao studentDao;*/

    @Resource(name = "studentDao")
    StudentDao studentDao;

    /*public void save() {
        studentDao.save();
    }*/

    public void save() {
        System.out.println("StudentService.save()");
        System.out.println(10/0);
    }

    public void delete() {
        System.out.println("StudentService.delete()");
    }
}

3、UserService

package com.ffyc.spring1.service;

import com.ffyc.spring1.dao.UserDao;
import com.ffyc.spring1.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service(value = "userService")
@Transactional
public class UserService {
    @Autowired
    UserDao userDao;

/*    public void save() {
        System.out.println("执行了UserService的save");
        userDao.save();
    }*/

    public List<User> findAllUsers() {
        List<User> users = userDao.findAllUsers();
        return users;
    }

    public UserService() {
    }

    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }

    public UserDao getUserDao() {
        return userDao;
    }

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
}

五、Util工具包

MyBatis

package com.ffyc.spring1.util;

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

@Component
@Aspect
public class MyUtil {

    @Before("execution(* com.ffyc.spring1.service.StudentService.save(..))")
    public void saveLog() {
        System.out.println("日志");
    }

    @After("execution(* com.ffyc.spring1.service.StudentService.save(..))")
    public void commit() {
        System.out.println("提交");
    }

    @Around("execution(* com.ffyc.spring1.service.StudentService.delete())")
    public void around(ProceedingJoinPoint proceedingJoinPoint) {
        System.out.println("=======前=======");
        try {
            proceedingJoinPoint.proceed();
        } catch (Throwable e) {
            e.printStackTrace();
        }
        System.out.println("=======后=======");
    }

    @AfterThrowing(value = "execution(* com.ffyc.spring1.service.StudentService.save())", throwing = "e")
    public void execption(Throwable e) {
        System.out.println("异常通知：" + e.getMessage());
    }

}

六、配置文件

1、pom.xml

2、config.properties

dirverClassName=com.mysql.cj.jdbc.Driver
url = jdbc:mysql://127.0.0.1:3306/ffycdb?characterEncoding=utf8&useSSL=false&serverTimezone=Asia/Shanghai
uname = root
password = root

3、spring_backups1.xml（备份的一份spring配置文件）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://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">
        <!-- 配置spring要管理的标签 -->
        <!--
            id 生成的对象名
            class 全类名
            name 对象别名,可以为多个
            scope:
                singleton(默认值):在 Spring 中只存在一个 bean 实例, 单例模式.
                prototype:原型 getBean()的时候都会 new Bean()
                request:每次 http 请求都会创建一个 bean, 仅用于 WebApplicationContext 环境
                session:同一个 http session 共享一个 Bean, 不同 Session 使用不同的 Bean, 使用环境同上
         -->
        <!--<bean id="user" class="com.ffyc.spring1.model.User"></bean>-->

        <!-- set方法注入 -->
        <bean id="user" class="com.ffyc.spring1.model.User">
            <property name="userId" value="1"></property>
            <property name="userAccount" value="11"></property>
            <property name="userPassword" value="111"></property>
        </bean>

        <!-- 构造方法注入 -->
        <!--<bean id="user" class="com.ffyc.spring1.model.User">
            <constructor-arg name="userId" value="2"></constructor-arg>
            <constructor-arg name="userAccount" value="22"></constructor-arg>
            <constructor-arg name="userPassword" value="222"></constructor-arg>
        </bean>-->

        <!-- 生成UserDao对象 -->
        <bean id="userdao" class="com.ffyc.spring1.dao.UserDao"></bean>
        <!-- 生成UserService对象，同事注入userDao -->
        <bean id="userservice" class="com.ffyc.spring1.service.UserService">
            <property name="userDao" ref="userdao"></property>
        </bean>

        <context:component-scan base-package="com.ffyc.spring1"></context:component-scan>

</beans>

4、spring_backups2.xml（备份的一份spring配置文件）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://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:component-scan base-package="com.ffyc.spring1"></context:component-scan>

    <!--  导入另一个配置文件  -->
    <import resource="db.xml"></import>

    <!--  基于xml方式  -->
    <!--  配置装有通知的类，将此类交给spring管理  -->
    <bean id="myutil" class="com.ffyc.spring1.util.MyUtil"></bean>

    <!--  编织/织入  -->
    <aop:config>
        <!--  配置切入点  -->
        <aop:pointcut id="save" expression="execution(* com.ffyc.spring1.service.StudentService.save(..))"/>
        <aop:pointcut id="delete" expression="execution(* com.ffyc.spring1.service.StudentService.delete(..))"/>
        <!--  为切入点配置通知  -->
        <aop:aspect ref="myutil">
            <!--  前置通知  -->
            <aop:before method="saveLog" pointcut-ref="save"></aop:before>
            <!--  后置通知  -->
            <aop:after method="commit" pointcut-ref="save"></aop:after>
            <!--  环绕通知  -->
            <aop:around method="around" pointcut-ref="delete"></aop:around>
            <!--  异常通知  -->
            <aop:after-throwing method="execption" throwing="e" pointcut-ref="save"></aop:after-throwing>
        </aop:aspect>
    </aop:config>

</beans>

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

    <context:component-scan base-package="com.ffyc.spring1"></context:component-scan>

    <!--  导入另一个配置文件  -->
    <import resource="db.xml"></import>

    <!--  基于注解方式  -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    <!-- 配置 spring 事务管理类, 并注入数据源 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 开启注解事务管理 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

</beans>

七、demo测试包

1、Demo1

package com.ffyc.spring1.demo.day2;

import com.ffyc.spring1.service.StudentService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Demo2_1 {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
        StudentService studentService = app.getBean("studentService", StudentService.class);

        studentService.save();

        System.out.println("-------------------------------------");

        studentService.delete();
    }
}

2、Demo2

package com.ffyc.spring1.demo.day2;

import com.ffyc.spring1.service.BankService;
import com.ffyc.spring1.service.StudentService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Demo2_2 {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
        BankService bankService = app.getBean("bankService", BankService.class);

        bankService.transMoney();
    }
}

ReNola
关注
专栏目录
简单的JavaWeb项目，适合入门练习
01-12
简单的JavaWeb项目，适合入门练习,用的jdbc连接oracle
hutool SpringUtil.getBean() NullPointerException
m0_49804107的博客
08-12 8469
hutool SpringUtil.getBean() NullPointerException
Spring学习笔记_01
weixin_44415250的博客
02-23 273
1.Spring是什么 简单来说，spring是一个IOC(DI)和AOP容器框架 IOC(Inversion of Control)：即控制反转，反转资源获取的方向，容器主动地将资源推送给它所管理的组件。 DI(Dependency Injection):即依赖注入，IOC的另一种表述方式，组件以一些预先定义好的方式接受来自如容器的注入。 2.在Spring的IOC容器里配置Bean(这里先...
JavaWeb基础学习一无框架项目小练习
qq_35515283的博客
03-16 2110
使用servlet和mysql还有java弄一个原生的javaWeb小项目，无框架
JavaWeb开发框架——Spring练习
weixin_44623055的博客
03-18 1315
1、Spring练习环境搭建 1.1、Spring环境搭建步骤 创建工程（Project & Module）； 导入静态页面； 导入需要坐标； 创建包结构（controller、service、dao、domain、utils）； 导入数据库脚本； 创建POJO类； 创建配置文件（applicationContext.xml、spring-mvc.xml、jdbc,properties、log4j.properties）。 pom.xml: ... <depend
javaweb练习项目
01-17
综上所述，这个“javaweb练习项目”提供了一个全面的JavaWeb学习环境，涵盖了从后端服务器处理、数据库交互到前端展示的各个环节。对于初学者来说，这是一个极好的实践平台，可以深入了解JavaWeb开发的各个环节，并...
javaweb学习与练习
最新发布
03-14
本资源包“javaweb学习与练习”显然旨在帮助初学者或开发者深入理解和掌握这一领域的核心概念和实践技巧。 JavaWeb的核心包括Servlet、JSP（JavaServer Pages）、JSTL（JavaServer Pages Standard Tag Library）...
学习javaweb练习的代码Java资源
06-21
JavaWeb是一种基于Java技术的Web开发框架，它涵盖了Servlet、JSP、JSTL、过滤器、监听器、MVC模式、Spring MVC、Struts、Hibernate等众多技术。本资源集合是一系列学习JavaWeb开发的实践代码，适用于初学者及进阶者...
JavaWeb练习题.zip
04-20
在这个"JavaWeb练习题.zip"压缩包中，我们可以推测包含的是作者田超凡设计的一些JavaWeb相关的练习题目，旨在帮助学习者巩固和提升JavaWeb开发技能。 JavaWeb开发主要包括以下几个关键知识点： 1. **Servlet**：...
JavaWeb上机练习14.zip
04-20
这个练习可能旨在帮助学习者深化对JavaWeb开发的理解，提升实际操作技能。JavaWeb是一个广泛的概念，它涵盖了使用Java语言进行Web应用程序开发的各种技术和工具。下面我们将深入探讨JavaWeb相关的知识点，以及可能在...
javaWeb项目 filter练习
04-08
JavaWeb项目 filter练习，编码过滤，登录过滤，较详细。
适合个人练习的13个javaweb项目明确任务书
08-24
在线考试系统的设计与实现,企业会议室管理系统的设计与实现,物流管理系统,企业项目管理系统平台,等
六款Javaweb练手项目
11-17
六款Javaweb练手项目
spring小练习
09-01
对应博主写的一些spring中IoC和AOP文章的代码，都是一些很简单的小例子，适合入门做练手
java web练习项目
Mas的博客
01-17 1039
java web练习项目 这是以前跟网课学的东西，现在放出来，仅仅是回顾一下，内容比较一般，我水平比较差，就是跟老师打出来。先来看一下效果图。 展示页面涉及的分类，页面定位，及后台对前端的增删改都是亲测有效的。有任何想问的，别问（反正我不是大牛）。 环境配置 环境的配置是比较麻烦的，小白要下载很多东西： apache-tomcat-8.5.61，记得下8的，这个老师说是好用。 JDK1.8. Dom4j-2.1到2.5, jQuery,Ajax依赖包 eclipse java jee。 注意安装的是这
JAVA web实践项目（附答案）
luyixs的博客
04-06 2610
JAVA web实践项目（附答案）
JavaWeb学习完成后的小项目练习
qq_43853323的博客
03-27 1684
javaWeb学习的练习小项目，完成了登陆注册，文件上传，验证码，用户的增删查改，多表联查
java web学习笔记
山海可平的博客
12-18 304
创建java web项目 idea+tomcat7 新建web项目 目录结构如下 配置tomcat 运行，并通过浏览器访问 Servlet 什么是servlet servlet 是java web 开发的基石，它是运行在servlet容器中（tomcat）中，负责与客户端进行通信。 servlet功能： 创建 并返回基于客户端请求的动态html页面。 与数据库进行通信 Servlet 使用 Servlet本身是一组接口，自定义一个类，实现servlet接口，这个类就具备了接收客户端请求
JavaWeb项目练习（一）——客户信息管理系统
热门推荐
weixin_41072833的博客
07-17 2万+
一、项目介绍     1.1. 功能介绍      添加客户：添加客户信息，其中包括姓名、性别、手机、邮箱和自我描述     查询客户：查询数据库中的所有客户信息，查询结果以列表分页形式展示，可以对展示列表的客户信息进行编辑和删除     高级搜索：可根据客户信息模糊搜索，搜索的结果以列表分页形式展示，可对展示列表的客户信息进行编辑和删除      1.2. 运用知识      *数...
基于spring的javaweb练习项目有哪些
04-19
关于基于Spring的JavaWeb练习项目，我可以给您提供一些常见的选择，比如基于Spring MVC框架的在线商城、基于Spring Boot的博客系统、基于Spring Security的权限管理系统等等。这些项目都比较实用，并且涵盖了不同的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值