Spring基础回顾

最新推荐文章于 2024-05-09 09:47:45 发布
最新推荐文章于 2024-05-09 09:47:45 发布
阅读量340 收藏
点赞数
文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/java_xhh/article/details/122070976
版权

一、概述

概述：spring就是一个轻量级的控制反转和面向切面编程的框架
在这里插入图片描述

二、自动装配在这里插入图片描述

三、AOP

basePackages

1、XML方式

			<dependency>
	            <groupId>org.aspectj</groupId>
	            <artifactId>aspectjweaver</artifactId>
	            <version>1.9.7</version>
	        </dependency>
	        <dependency>
	            <groupId>org.springframework</groupId>
	            <artifactId>spring-webmvc</artifactId>
	            <version>5.3.13</version>
	        </dependency>


import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class Log1 implements MethodBeforeAdvice {

    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
        System.out.println("参数为："+args[0]);
    }
}

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class Log2 implements AfterReturningAdvice {


    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);
    }
}

public class Log3 {

public void before(){
    System.out.println("======before=======");
}
public void after(){
    System.out.println("======after=======");
}

}

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

    <!-- bean definitions here -->


    <bean id="userService" class="com.kuangshen.service.UserServiceImpl"/>
    <bean id="log1" class="com.kuangshen.log.Log1"/>
    <bean id="log2" class="com.kuangshen.log.Log2"/>
    <bean id="log3" class="com.kuangshen.log.Log3"/>

    <!-- 配置AOP，需要导入aop的约束-->
    <aop:config >
        <!--切入点  execution表达式：excution(要执行的位置 * * * * *）-->
        <aop:pointcut id="pointcut" expression="execution(* com.kuangshen.service.UserServiceImpl.*(..))"/>
        <!--执行环绕增加-->
        <aop:advisor advice-ref="log1" pointcut-ref="pointcut" />
        <aop:advisor advice-ref="log2" pointcut-ref="pointcut" />
    </aop:config>

    <!--自定义类-->
    <aop:config>
        <!--自定义切面，ref要引用的类-->
        <aop:aspect ref="log3">
            <!--切入点-->
            <aop:pointcut id="pointcut" expression="execution(* com.kuangshen.service.UserServiceImpl.*(..))"/>
            <aop:before method="before" pointcut-ref="pointcut"/>
            <aop:after method="after" pointcut-ref="pointcut" />
        </aop:aspect>
    </aop:config>
</beans>


public class AopTest {

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

2、注解


@Configuration
@ComponentScan(basePackages={"com.kuangshen.pojo","com.kuangshen.aspect"})
@EnableAspectJAutoProxy
public class AppConfig {

    @Bean
    public User getUser(){
        return new User();
    }

    @Bean
    public UserServiceImpl userService(){
        return new UserServiceImpl();
    }


}


import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.aop.MethodBeforeAdvice;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
@Aspect
@Component
public class Log {

    @Before("execution(* com.kuangshen.service.UserServiceImpl.*(..))")
    public void before() throws Throwable {
        System.out.println("=====执行前=====");
    }
    @After("execution(* com.kuangshen.service.UserServiceImpl.*(..))")
    public void after() throws Throwable {
        System.out.println("=====执行后=====");
    }


}


public class AppTest {

    @Test
    public void testBean(){
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        IUserService userService = context.getBean("userService", IUserService.class);
        userService.add("我爱你~");
    }
}

四、事务

在这里插入图片描述

1.pom文件

pom

<dependencies>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.27</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.13</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.13</version>
        </dependency>
    </dependencies>

mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>
    <typeAliases >
        <package name="com.kuang.pojo"/>
    </typeAliases>
    <mappers>
        <package name="com.kuang.mapper"/>
    </mappers>
</configuration>

spring-dao.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"
       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/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--        &lt;!&ndash;DataSource:使用Spring的数据源替换Mybatis的配置  c3p0  dbcp  druid-->
    <!--    我们这里使用Spring提供的JDBC : org.springframework.jdbc.datasource-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis-study?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

    <!--sqlSessionFactory 注释-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!--绑定Mabatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
    </bean>
    <!--SqlSessionTemplate:就是我们使用的sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
    <!--配置声明式事务-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <constructor-arg ref="dataSource" />
    </bean>
    <!--结合AOP实现事务的织入-->
    <!--配置事务通知；-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--给那些方法配置事务-->
        <!--配置事务的传播特性：new  propagation= -->
        <tx:attributes>
            <tx:method name="add" propagation="REQUIRED"/>
            <tx:method name="delete" propagation="REQUIRED"/>
            <tx:method name="update" propagation="REQUIRED"/>
            <tx:method name="query" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!--配置事务切入-->
    <aop:config>
        <aop:pointcut id="txPointCut" expression="execution(* com.kuang.service.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>
</beans>

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: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/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd">

    <import resource="classpath:spring-dao.xml" />

    <bean id="userMapper" class="com.kuang.mapper.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>
    <bean id="userService" class="com.kuang.service.UserServiceImpl">
        <property name="userMapper" ref="userMapper"/>
    </bean>

</beans>

UserMapperImpl


public class UserMapperImpl implements UserMapper{

    private  SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }
    @Override
    public List<User> queryList() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.queryList();
    }

    @Override
    public int addUser(User user) {
        return sqlSession.getMapper(UserMapper.class).addUser(user);
    }

    @Override
    public int deleteUser(@Param("id") int id) {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.deleteUser(id);
    }
}

Test


public class TestUserMapper {

    public static void main(String[] args) throws Exception {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper mapper = context.getBean("userMapper", UserMapper.class);
        List<User> users = mapper.queryList();
        for (User user:users){
            System.out.println(user.toString());
        }
    }

    @Test
    public void testUserService(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserSerivce userService = context.getBean("userService", UserSerivce.class);
        userService.bus();
    }
}
java_xhh
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring基础知识简单回顾
12-21
Spring框架概述    Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。    目的:解决企业应用开发的复杂性。    功能：使用基本的javaBean来代替EJB，并提供了更多功能。    范围：所有java应用，不局限于服务端开发。   简述：spring是一个轻量级控制反转和面向切面的框架。 IoC（控制反转） IoC概述    Spring通过一种称作控制反转（
microservice_springcloud2:第二个基于SpringCloud 搭建的微服务架构案例
05-16
至少是比较了解了SC 最核心的五个组件（Eureka，Feign，Ribbon，Zuul，Config），第二个案例继续在第一个案例的基础上，再一次通过从零搭建（就跟搭积木一样），回顾一个基础的微服务架构到底需要哪些组件，SC是如何...
回顾 Spring
m0_61470267的博客
11-11 352
依赖关系：当一个对象a的某些操作需要通过调用另一个对象b中的方法来实现时，说明a依赖于对象b，a与b是依赖关系。IoC：控制反转使用者之前使用对象的时候都需要自己手动的创建和组装，而现在这些创建和组装都交给了spring容器来进行管理，需要使用这个对象的时候，我们可以直接去spring容器中查找使用这个对象。之前创建和组装对象都是我们自己手动的进行创建，现在交由spring来进行创建和组装了，对象的构建被反转了，就叫做控制反转。...............
什么是Spring
weixin_50302693的博客
08-24 328
什么是Spring 1、spring是什么？它包括哪几个部分？ Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control： 反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多 著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。
spring回顾系列——快速了解spring,使用spring开发
m0_54500212的博客
09-03 1262
spring的初步认识，spring 的快速使用
spring回顾
百年城的博客
07-28 166
一、spring基本介绍 前言：系统的复习一遍spring 概念 Spring 是轻量级的开源的JavaEE框架 Spring可以解决企业应用开发的复杂性 Spring的两大核心部分:IOC和Aop IOC:控制反转，将创建对像的过程交给Spring进行管理 Aop:面对切面,在不修改源代码进行功能增强 特点 方便解耦，简化开发 通过IOC容器，对象依赖交予Spring进行控制，避免硬编码带来的程序耦合。并且，不必为单例模式、属性文件解析等底层需求编写代码，专注于上层的应用。 Aop编程支
Java进阶教程数据层全栈方案SpringData高级应用视频教程
11-05
第三章 SpringData JPA基础 1.SpringData JPA简介 2.SpringData JPA快速入门 3.SpringData Jpa运行原理分析 第四章 SpringData JPA的多种查询方式 1.父接口方法查询 2.方法命名规则查询 3.JPQL查询 4.本地SQL查询 5....
spring培训笔记
05-07
spring基础 知识要点： Spring的事务管理及实现，Spring操作Hibernate的事务管理器； 回顾上次课的要点： 代理模式，AOP框架，Spring中AOP的实现方式 一、Spring的事务管理 传统数据库事务的特性： Atomic: ...
Spring基础知识回顾
m0_46245027的博客
08-23 91
Spring基础知识回顾一. Bean定义：二、动态代理三、自动装配 复习基础知识 一. Bean定义： 配置文件配置：纯XMl 配置来管理bean 的话，所有与bean相关的一切配置都会写在配置文件中 xml和注解配置：bean可以不在xml配置文件中去定义 <context:component-scan base-package=“相关bean配置的目录”></context:component-scan> Java代码中作为bean 配置的话需要加上@Component
SpringBoot 学习笔记（一）——Spring回顾与SpringMVC基础
KeepTing
06-09 655
Spring Boot学习笔记（一）一、Spring 回顾1、声明Bean 的注解 @Component 组件，没有明确的角色 @Service 业务逻辑层（service层）使用 @Repository 数据访问层（dao层）使用 @Controller 控制器（MVC） 2、注入Bean 的注解 @AutoWired：Spring 提供的注解 @Inject：JSR-330提供的注
Spring全回顾之HelloWrold
fx9590的博客
05-16 276
Spring作为一个java程序员不可绕过优秀框架，我们应该向掌握JDk一样掌握Spring。作为认识Spring开始，那就从Spring HelloWorld开始首先来引入相应的jar，虽然现在基本都使用Maven作为jar包的管理，但是为了更好了解学习Spring，我这里采用手动导入jar包方式。为了方便下载可以在http://repo.springsource.org/libs-releas...
spring基础部分知识点回顾
小唐同学的博客
08-02 297
简介 最近学习了很多框架的知识，spring，springmvc，mybatis等等，这些框架让我感受到便利的同时也让我感受到了需要记忆了解的内容的量很大，很快的接触很多框架有点应接不暇，所以想总结一下框架的使用要点 知识点回顾 1.通过IOC实现对对象的管控 1.1 IOC使用步骤 1.引入jar包，通过maven引入对应依赖实现。 IOC实现需要的包的groupId都是org.springframework 具体需要的包的artifactId如下所示： spring-core（Spring的核心工具包
spring——控制反转
java开发指南博客 【转载】
03-09 279
像前面博客中提到struts框架，Hibernate框架似的，spring同样也是一个开源的框架。使用框架的的优势在于分层结构，每层有相应的框架，减少开发工作量，减少组件之间的耦合。struts框架应用web层，Hibernate框架应用持久层，spring应用两者之间。 我觉得，框架是出于聪明的赖人之手。聪明是说他们开发封装每层框架，把复杂的操作全部封装在框架中。而赖人是说他所有复杂的操作...
Spring回顾
mojo-jj的博客
04-24 127
1、Spring 一款轻量级的控制反转（IoC)和面向切面（AOP)的框架 2、IoC 控制反转：讲对象的创建，管理，转配交给IoC容器 实现方式：依赖注入（提供set方法） @Test public void shouldAnswerWithTrue() { ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml"); User user = (User) context.getBean("
spring 回顾一
zx1323的博客
01-20 195
Spring是什么？ 1.轻量级：可实现零配置编程，api使用简单 2.bean：豆子，非常普通的对象，不需要依赖其他的东西 3.松耦合：充分利用aop思想 4.万能胶：与主流框架无缝集成 5.设计模式：将java中的经典设计模式运用的淋漓尽致 Spring设计背景 立志于全方面的简化java开发，4个策略 1.基于POJO的轻量级和最小倾入性编程 2.通关依赖注入和面相
基于springboot实现智慧图书管理系统项目【项目源码+论文说明】
最新发布
ybigbear2的博客
05-09 780
本课题研发的智慧图书管理系统，就是提供图书借阅信息处理的解决方案，它可以短时间处理完信息，并且只需要使用者动动鼠标和键盘就能获取自己需要的信息，并且这些信息都有专门的存储设备，而且数据的备份和迁移都可以设定为无人值守，从人力角度和信息处理角度以及信息安全角度，智慧图书管理系统是完胜传统纸质操作的，所以智慧图书管理系统就是如此的值得信赖。图4.1即为设计的管理员功能结构，管理员权限操作的功能包括对注册读者信息的管理，对图书，对图书留言，对图书借阅记录，对论坛帖子等信息的管理。
毕业就业信息|基于Springboot＋vue的毕业就业信息管理系统的设计与实现(源码+数据库+文档)
伟庭的博客
05-07 1059
毕业就业信息管理系统在对开发工具的选择上也很慎重，为了便于开发实现，选择的开发工具为Eclipse，选择的数据库工具为Mysql。以此搭建开发环境实现毕业就业信息管理系统的功能。其中管理员管理用户，新闻公告。毕业就业信息管理系统是一款运用软件开发技术设计实现的应用系统，在信息处理上可以达到快速的目的，不管是针对数据添加，数据维护和统计，以及数据查询等处理要求，毕业就业信息管理系统都可以轻松应对。关键词：毕业就业信息管理系统；SpringBoot框架，系统分析，数据库设计。
spring 基础代码
07-13
对于Spring框架的基础代码，以下是一个简单的示例： ```java import org.springframework.context.ApplicationContext; import org.springframework.context.annotation.AnnotationConfigApplicationContext; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值