Spring小记

最新推荐文章于 2021-05-27 17:44:06 发布
最新推荐文章于 2021-05-27 17:44:06 发布
阅读量227 收藏
点赞数
分类专栏： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43942304/article/details/117327565
版权
本文详细介绍了如何在Spring中使用XML配置和注解方式实现自动装配，以及如何通过AOP进行事务管理，重点展示了如何在IOC容器中注入复杂类型和多个接口实现类，并结合JdbcTemplate进行数据库操作。
摘要由CSDN通过智能技术生成

Spring小记

从IOC容器获取bean

ClassPathXmlApplicationContext（从类路径获取文件） 和 FileSystemXmlApplicationContext（从系统磁盘径获取文件）。

方式一（ClassPathXmlApplicationContext（从类路径获取文件）方式）：
实体类：

public class Person {
    private String name;
    private Integer age;
    
    public Person() {
        super();
        System.out.println("构造方法被调用");
    }
        //getters、setters、toString
}

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：使容器创建Person的对象 -->
    <!-- name：相当于变量名 Person p = new Person(); -->
    <!-- class：类的全限定名 -->     
    <bean name="p" class="com.qfedu.spring.pojo.Person"></bean>   
</beans>

获取bean测试：

public class IOCTest {
    @Test
    public void testCreatePerson() {
        
        //创建容器
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //查找对象
        Person p = (Person)context.getBean("p");
        System.out.println(p);
    }
}

方式二（FileSystemXmlApplicationContext（从系统磁盘径获取文件）方式）：

 @Test
    public void ApplicationContext() {    
        //创建容器
        ApplicationContext context = new FileSystemXmlApplicationContext("D:\\workspace_helen\\web-gp1701\\spring-01-hello\\src\\applicationContext.xml");
    }

复杂类型注入

    private Object[] cars;//数组类型的注入
    private List friends; //list类型的注入
    private Set set;//set类型的注入
    private Map map;//map类型的注入
    private Properties properties;//properties类型的注入

<bean name="person5" class="com.qfedu.spring.pojo.Person">
        <property name="name" value="houkunpeng"></property>
        <property name="age" value="16"></property>
        <property name="car" ref="car"></property>
        <property name="cars">
            <array>
                <value>自行车</value>
                <value>手扶拖拉机</value>
                <ref bean="car" />
            </array>
        </property>
        <property name="friends">
            <list>
                <value>洋妞红</value>
                <value>溜冰摔</value>
                <value>少元彬</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>set3</value>
                <value>set2</value>
                <value>set1</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="username" value="root"></entry>
                <entry key="car" value-ref="car"></entry>
                <entry key-ref="person1" value-ref="car"></entry>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="username">root</prop>
                <prop key="password">123456</prop>
            </props>
        </property>
        
    </bean>

一个接口有多个实现类，如何自动装配

自动装配存在的问题：如果一个类型有多个对象（一个接口有多个实现类），那么可以采用以下的方式：
TestService接口：

public interface TestService {
    public void getMessage();
}

TestServiceImpl实现TestService:

@Service
public  class TestServiceImpl implements TestService {

    @Override
    public void getMessage() {
        System.out.println("test serviceImpl one");
    }
}

TestServiceImpl2实现TestService:

@Service
public class TestServiceImpl2 implements TestService {
    @Override
    public void getMessage() {
        System.out.println("test serviceImpl tow");
    }
}

测试类:
解决装配起义性的方式有三种

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
class TestServiceImplTest {

    // 方式一
//    @Autowired // 按照byType自动装配
//    @Qualifier("testServiceImpl") // 按照byName,类名首字母小写

    // 方式二
 //   @Resource(type = com.xmm.springboot_lab.service.impl.TestServiceImpl.class)// 按照byType
    // 方式三
    @Resource(name = "testServiceImpl2") //按照byName，类名首字母小写
    private TestService testService;

    @Test
    void getMessage() {
        testService.getMessage();
    }
}

AOP

aop和代理：blog.csdn.net/qq_41701956/article/details/84427891

AOP是能够让我们在不影响原有功能的前提下，为软件横向扩展功能。

方式一
aop通过xml方式：

public class UserServiceImpl implements UserService{
    @Override
    public void save() {
        System.out.println("保存用户");
    }
    @Override
    public void delete() {
        System.out.println("删除用户");
    }
    @Override
    public void update() {
        System.out.println("更新用户");
    }
    @Override
    public void select() {
        System.out.println("查询用户");
    }
}

切面类：

public class TransactionAdvice {
//    前置通知：在目标方法之前调用
//    后置通知（如果出现异常就不调用）：在目标方法之后调用
//    返回通知（无论是否出现异常都会调用）：在目标方法之后调用
//    环绕通知：在目标方法之前、后调用
//    异常通知：出现异常则调用
    
    public void before() {
        System.out.println("前置通知被执行");
    }
    
    public void afterReturning() {
        System.out.println("后置通知被执行（出现异常不调用）");
    }
    
    public void after() {
        System.out.println("后置通知被执行（无论是否出现异常都会调用）");
    }
    
    public void afterException() {
        System.out.println("异常通知被执行");
    }
    
    public Object around(ProceedingJoinPoint point) throws Throwable {
        System.out.println("");
        Object proceed = point.proceed();//调用目标方法
        System.out.println("");
        return proceed;
    }
}

xml配置：

<!-- 目标对象 -->   
    <bean name="userService" class="com.qfedu.spring.aop.service.UserServiceImpl"></bean>
    
    <!-- 通知对象 -->
    <bean name="transactionAdvice" class="com.qfedu.spring.aop.advice.TransactionAdvice"></bean>
    <!-- 将通知对象织入目标对象 -->
    <aop:config>
        <!-- 选择切入点 -->
        <aop:pointcut expression="execution(* com.qfedu.spring.aop.service..*ServiceImpl.*(..))" id="pointcut"/>
        <aop:aspect ref="transactionAdvice">
            <aop:before method="before" pointcut-ref="pointcut"/>
            <aop:after-returning method="afterReturning" pointcut-ref="pointcut"/>
            <aop:after method="after" pointcut-ref="pointcut"/><!-- 无论是否出现异常都会调用 -->
            <aop:around method="around" pointcut-ref="pointcut"/>
            <aop:after-throwing method="afterException" pointcut-ref="pointcut"/>
        </aop:aspect>
    </aop:config>

测试：

//创建容器
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Resource(name="userService")
    private UserService userService;
    
    @Test
    public void testSave() {
        userService.save("helen");
    }  
    @Test
    public void testUpdate() {
        userService.update();
    }
}

方式二
aop通过注解方式：

public class UserServiceImpl implements UserService{
    @Override
    public void save() {
        System.out.println("保存用户");
    }
    @Override
    public void delete() {
        System.out.println("删除用户");
    }
    @Override
    public void update() {
        System.out.println("更新用户");
    }
    @Override
    public void select() {
        System.out.println("查询用户");
    }
}

切面类：

@Aspect
public class TransactionAdvice {
    @Pointcut("execution (* com.qfedu.spring.aop.service..*ServiceImpl.*(..))")
    private void anyMethod() {} // 声明一个切入点，anyMethod为切入点名称
    
     // 声明该方法是一个前置通知：在目标方法开始之前执行 
    @Before("anyMethod()")
    public void doAccessCheck() {
          System.out.println("前置通知被执行");
    }
}

xml配置：

 <!-- 目标对象 -->   
    <bean name="userService" class="com.qfedu.spring.aop.service.UserServiceImpl"></bean>
    
    <!-- 通知对象 -->
    <bean name="transactionAdvice" class="com.qfedu.spring.aop.advice.TransactionAdvice"></bean>
    <!-- 开启织入注解 -->
   <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

测试：

/创建容器
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Resource(name="userService")
    private UserService userService;
    
    @Test
    public void testSave() {
        userService.save("helen");
    }
    
    @Test
    public void testUpdate() {
        userService.update();
    }
}

Jdbc Tempalte

实体类：

public class Role {
    private Integer rid;
    private String rname;
    private String alias;
    //空参构造、getters、setters
    @Override
    public String toString() {
        return "Role [rid=" + rid + ", rname=" + rname + ", alias=" + alias + "]";
    }
}

dao接口：

package com.qfedu.spring.dao;
public interface RoleDao {
    void save(Role role);
    
    void delete(Integer id);
    
    void update(Role role);
    
    Role getById(Integer id);
    
    List<Role> getAll();
    
    int getTotalCount();
}

实现dao接口：

package com.qfedu.spring.dao;
public class RoleDaoImpl implements RoleDao{
    JdbcTemplate jt;
    public void setJt(JdbcTemplate jt) {
        this.jt = jt;
    }
    @Override
    public void save(Role role) {
        String sql = " INSERT INTO ar_role ( "
                + " rname,"
                + " alias"
                + " ) VALUES (?,?)" ;
        jt.update(sql, role.getRname(), role.getAlias());
    }
    @Override
    public void delete(Integer id) {
        String sql = " delete from ar_role where rid = ?" ;
        jt.update(sql, id);
    }
    @Override
    public void update(Role role) {
        String sql = " update ar_role set rname = ?, alias = ? where id = ?";
        jt.update(sql, role.getRname(), role.getAlias(), role.getRid());
    }
    @Override
    public Role getById(Integer id) {
        String sql = "select * from ar_role where rid = ?";
        Role role = jt.queryForObject(sql, new RowMapper<Role>() {
            @Override
            public Role mapRow(ResultSet rs, int index) throws SQLException {
                return maoRowHandler(rs);
            }
        }, id);
        return role;
    }
    @Override
    public List<Role> getAll() {
        String sql = "select * from ar_role";
        List<Role> list = jt.query(sql, new RowMapper<Role>() {
            @Override
            public Role mapRow(ResultSet rs, int index) throws SQLException {
                return maoRowHandler(rs);
            }
        });
        return list;
    }
    @Override
    public int getTotalCount() {
        String sql = "select count(1) from ar_role";
        Integer count = jt.queryForObject(sql, Integer.class);
        return count;
    }
    
    private Role maoRowHandler(ResultSet rs) throws SQLException {
        Role role = new Role();
        role.setRname(rs.getString("rname"));
        role.setAlias(rs.getString("alias"));
        role.setRid(rs.getInt("rid"));
        return role;
    }
}

创建db.properties：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring-gp1701
jdbc.username=root
jdbc.password=123456

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:property-placeholder location="classpath:db.properties" />        
<!-- 连接池 -->
<bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${jdbc.driver}"></property>
    <property name="jdbcUrl" value="${jdbc.url}"></property>
    <property name="user" value="${jdbc.username}"></property>
    <property name="password" value="${jdbc.password}"></property>
</bean>
<!-- JdbcTemplate -->
<bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"></property>
</bean>
<!-- roleDao -->
<bean name="roleDao" class="com.qfedu.spring.dao.RoleDaoImpl">
    <property name="jt" ref="jdbcTemplate"></property>
</bean>
</beans>

测试：

package com.qfedu.spring.jdbctemplate;
//创建容器
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestSpringJdbcTemplate {
    
    @Resource(name="roleDao")
    private RoleDao roleDao;
    
    @Test
    public void testSave(){
        
        Role role = new Role();
        role.setRname("spring1");
        role.setAlias("spring11");
        roleDao.save(role);
    }
    
    @Test
    public void testDelete(){
        
        roleDao.delete(5);
    }
    
    @Test
    public void testUpdate(){
        Role role = new Role();
        role.setRname("spring4");
        role.setAlias("spring44");
        role.setRid(4);
        roleDao.update(role);
    }
    
    @Test
    public void testGetById(){
        Role role = roleDao.getById(4);
        System.out.println(role);
    }
    
    @Test
    public void testGetAll(){
        List<Role> roleList = roleDao.getAll();
        System.out.println(roleList);
    }
    
    @Test
    public void testGetTotalCount(){
        Integer count = roleDao.getTotalCount();
        System.out.println(count);
    }
}
weixin_43942304
关注
专栏目录
spring 小记
04-19
这篇小记将深入探讨Spring的主要组件和关键特性，带你一步步走进Spring的世界。 首先，我们要理解Spring的核心——依赖注入。在传统的Java程序中，对象之间的依赖关系通常是硬编码的，这使得代码难以测试和维护。...
尚硅谷Spring笔记
04-11
尚硅谷Spring笔记
spring jar包
08-05
spring-aop-3.2.2.RELEASE.jar spring-beans-3.2.2.RELEASE.jar spring-context-3.2.2.RELEASE.jar spring-context-support-3.2.2.RELEASE.jar spring-core-3.2.2.RELEASE.jar spring-data-commons-1.5.0.RELEASE....
springcloud源码
08-13
Spring Cloud 是一个基于 Spring Boot 实现的微服务框架，它为开发者提供了在分布式系统（如配置管理、服务发现、断路器、智能路由、微代理、控制总线、一次性令牌、全局锁、领导选举、分布式会话、集群状态）操作的...
spring-ai-core 0.8.1
最新发布
05-21
《Spring AI Core 0.8.1：开启人工智能之旅》 在现代软件开发领域，Spring框架以其强大的功能和灵活性，已经成为Java开发中的首选框架之一。而Spring AI Core则是Spring生态系统中专门为人工智能（AI）和机器学习...
spring中@Value的使用（读取配置文件信息）
weixin_43942304的博客
10-04 2020
选取任意一个spring-***文件写入： <context:property-placeholder location="classpath:database.properties,classpath:de.properties"/> springmvc @Value取值为NULL的解决方案 在spring mvc架构中，如果希望在程序中直接使用properties中定义的配置值，通常使用一下方式来获取： @Value("${tag}") private String t
AOP 详解 、AOP 中通知类型 、AOP 两种实现方式(Schema-base 和 AspectJ)
weixin_43942304的博客
09-07 520
一.AOP AOP:中文名称面向切面编程 英文名称:(Aspect Oriented Programming) 正常程序执行流程都是纵向执行流程 3.1 又叫面向切面编程,在原有纵向执行流程中添加横切面 3.2 不需要修改原有程序代码 3.2.1 高扩展性 3.2.2 原有功能相当于释放了部分逻辑.让职责更加明确. 面向切面编程是什么? 4.1 在程序原有纵向执行流程中,针对某一个或某一些方法添加通知,形成横切面过程就叫做面向切面编程. 常用概念 5.1 原有功能: 切点, point
启动web项目（maven）
weixin_43942304的博客
01-16 506
启动web项目（maven） 步骤6点击进去这个样子 点击步骤8后界面 最后别忘了点击apply和ok按钮,然后就可以启动项目了。
spring容器
weixin_43942304的博客
10-10 492
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>4.3.7.RELEASE</version> </dependency>
Spring 框架简介及官方压缩包目录
weixin_43942304的博客
09-07 378
一.Spring 框架简介及官方压缩包目录 介绍 主要发明者:Rod Johnson 轮子理论推崇者: 2.1 轮子理论:不用重复发明轮子 2.2 IT 行业:直接使用写好的代码. Spring 框架宗旨:不重新发明技术,让原有技术使用起来更加方便. Spring 几大核心功能 4.1 IoC/DI 控制反转/依赖注入 4.2 AOP 面向切面编程 4.3 声明式事务. Spring 框架 runtime 5.1 test: spring 提供测试功能 5.2 Core Container:核心容器.Sp
接口向mapper传参数
weixin_43942304的博客
11-19 365
接口向mapper传递参数 第一种方案 DAO层的函数方法 Public User selectUser(String name,String area); 对应的Mapper.xml <select id="selectUser" resultMap="BaseResultMap" parameterType="java.lang.String"> select * from user_user_t where user_name = #{0} and user_ar
自动注入、加载 properties 文件、scope 属性、单例设计模式
weixin_43942304的博客
09-07 303
一.自动注入 在 Spring 配置文件中对象名和 ref=”id”id 名相同使用自动注入,可以不配置<property/> 两种配置办法 2.1 在<bean>中通过 autowire=”” 配置,只对这个<bean>生效 2.2 在<beans>中通过 default-autowire=””配置,表当当前文件中所有<bean>都是全局配置内容 autowire=”” 可取值 3.1 default: 默认值,根据全局 default-aut
AOP的XML架构、AOP的@AspectJ
weixin_43942304的博客
10-09 168
AOP的XML架构 aop例子：https://www.w3cschool.cn/wkspring/omps1mm6.html AOP的XML架构传参 定义切面(包含五种通知): import org.aspectj.lang.ProceedingJoinPoint; public class MyXmlServiceAop { public void beforeHandler(String name, int age) { System.out.println("前置通知
声明式事务、Spring 中常用注解、Ajax
weixin_43942304的博客
09-07 145
五. 声明式事务 编程式事务: 1.1 由程序员编程事务控制代码. 1.2 OpenSessionInView 编程式事务 声明式事务: 2.1 事务控制代码已经由 spring 写好.程序员只需要声明出哪些方法需要进行事务控制和如何进行事务控制. 声明式事务都是针对于 ServiceImpl 类下方法的. 事务管理器基于通知(advice)的. 在 spring 配置文件中配置声明式事务 <context:property-placeholder location="classpath:db.p
springMVC小记
weixin_43942304的博客
05-27 132
springMVC小记SpringMVC 中重要组件spring容器和springMVC容器的关系跳转方式传参自定义拦截器拦截器栈SpringMVC 运行原理SpringMVC 对 Date 类型转换 SpringMVC 中重要组件 DispatcherServlet: 前端控制器,接收所有请求(如果配置/不包 含 jsp) HandlerMapping: 解析请求格式的.判断希望要执行哪个具体 的方法. HandlerAdapter: 负责调用具体的方法. ViewResovler:视图解析器.解析结果
Spring的jar包下载
weixin_43942304的博客
08-26 130
链接
使用 Spring 简化 MyBatis
weixin_43942304的博客
09-07 124
七.使用 Spring 简化 MyBatis 导 入 mybatis 所 有 jar 和 spring 基 本包,spring-jdbc,spring-tx,spring-aop,spring-web,spring 整合 mybatis 的包等 先配置 web.xml <?xml version="1.0" encoding="UTF-8"?> <web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:
spring自动装配、注解
weixin_43942304的博客
09-11 116
spring自动装配 Spring 自动装配 byName 这种模式由属性名称指定自动装配。Spring 容器看作 beans，在 XML 配置文件中 beans 的 auto-wire 属性设置为 byName。然后，它尝试将它的属性与配置文件中定义为相同名称的 beans 进行匹配和连接。如果找到匹配项，它将注入这些 beans，否则，它将抛出异常。 例如，在配置文件中，如果一个 bean 定义设置为自动装配 byName，并且它包含 spellChecker 属性（即，它有一个 setSpellChe
Spring框架实践指南
"Spring in Practice" 是一本由Willie Wheeler和Joshua White合著的书籍，专注于Spring框架的实践应用，适用于企业级Java开发者。本书是针对Spring 3版本编写的，旨在帮助读者掌握Spring框架在各种实际场景下的使用...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值