Spring FOUR

最新推荐文章于 2024-07-23 10:48:19 发布
最新推荐文章于 2024-07-23 10:48:19 发布
阅读量4k 收藏
点赞数
分类专栏： SSM 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46728644/article/details/120517629
版权

文章目录

第一章：Spring框架的JDBC模板技术

1. JDBC模板技术概述

什么模板技术：Spring框架中提供了很多持久层的模板类来简化编程，使用模板类编写程序会变的简单
template模板
都是Spring框架提供XxxTemplate
提供了JDBC模板，Spring框架提供的
JdbcTemplate类，Connection 表示连接，管理事务 Statement ResultSet

2. JDBC的模板类的使用

jdbc模板类的使用，创建maven工程，引入坐标依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
   <!-- 连接池-->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.10</version>
    </dependency>
   <!-- mysql驱动包-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>
    <!--AOP联盟-->
    <dependency>
    <groupId>aopalliance</groupId>
    <artifactId>aopalliance</artifactId>
    <version>1.0</version>
</dependency>
    <!--Spring Aspects-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-aspects</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <!--aspectj-->
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.3</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
</dependencies>

编写测试代码（自己来new对象的方式）

public class Demo4 {
    @Test
   public void run(){
        // 创建连接池对象，Spring框架内置了连接池对象
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        // 设置4个参数
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3308/spring_db");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        // 提供模板，创建对象
        JdbcTemplate template = new JdbcTemplate(dataSource);
        template.update("insert into account values(null,?,?)","告诉","2000");
    }
}

3. 使用Spring框架来管理模板类

刚才编写的代码使用的是new的方式，应该把这些类交给Spring框架来管理。
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
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="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3308/spring_db" />
        <property name="username" value="root" />
        <property name="password" value="root" />
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

编写测试方法

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:ApplicationContext_jdbc.xml")
public class Demo4 {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Test
   public void run(){
        jdbcTemplate.update("insert into account values(null,?,?)","告诉","2000");
    }
}

4. Spring框架管理开源的连接池

配置开源的连接池，使用Druid开源的连接池，引入坐标如下

<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.10</version>
</dependency>

将数据库连接的信息配置到属性文件中

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3308/spring_db
jdbc.username=root
jdbc.password=root

完成核心配置
注意点：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
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">
    <!--spring提供的连接池-->
    <!--<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3308/spring_db" />
        <property name="username" value="root" />
        <property name="password" value="root" />
    </bean>-->
    <!--第三方连接池-->
    <!--<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost:3308/spring_db" />
        <property name="username" value="root" />
        <property name="password" value="root" />
    </bean>-->
   <!-- 属性配置文件第一种写法-->
    <!--<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:jdbc.properties"/>
    </bean>-->
    <!-- 属性配置文件第二种写法-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>


    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

</beans>

5. Spring框架的JDBC模板的简单操作

增删改查代码编写
查询是难点，需要自己编写指定接口的实现类，作用是把查出的结果集封装

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value = "classpath:applicationContext_jdbc.xml")
public class Demo1_1 {
@Autowired
private JdbcTemplate jdbcTemplate;
/**
* 测试的方式
*/
@Test
public void run1(){
jdbcTemplate.update("insert into account values (null,?,?)","熊四",800);
}
/**
* 修改
*/
@Test
public void run2(){
jdbcTemplate.update("update account set name = ?,money = ? where id = ?","光头
强",100,7);
}
/**
* 删除
*/
@Test
public void run3(){
jdbcTemplate.update("delete from account where id = ?",7);
}
/**
* 通过id查询
*/
@Test
public void run4(){
Account account = jdbcTemplate.queryForObject("select * from account where id = ?", new
BeanMapper(), 6);
System.out.println(account);
}
/**
* 查询所有的数据
*/
@Test
public void run5(){
List<Account> list = jdbcTemplate.query("select * from account", new BeanMapper());
for (Account account : list) {
System.out.println(account);
}
}
}
/**
* 实现类，用来进行数据封装的
*/
class BeanMapper implements RowMapper<Account>{
/**
* 是一行一行进行数据封装的
* @param resultSet
* @param i
* @return
* @throws SQLException
*/
@Override
public Account mapRow(ResultSet resultSet, int i) throws SQLException {
Account account = new Account();
account.setId(resultSet.getInt("id"));
account.setName(resultSet.getString("name"));
account.setMoney(resultSet.getDouble("money"));
return account;
}
}

第二章：模拟转账开发

1. 完成转账代码的编写

搭建开发的环境
service代码的编写

public interface AccountService {
/**
* 转账的方法
* @param out 付款人
* @param in 收款人
* @param money 金额
*/
public void pay(String out,String in,double money);
}

package com.qcby.demo2;

public class AccountServiceImpl implements AccountService {
private AccountDao accountDao;
public void setAccountDao(AccountDao accountDao) {
this.accountDao = accountDao;
}
/**
* 转账方法
* @param out 付款人
* @param in 收款人
* @param money 金额
*/
@Override
public void pay(String out, String in, double money) {
// 调用dao方法
accountDao.outMoney(out,money);
accountDao.inMoney(in,money);
}
}

dao代码的编写（第一种方式）
package com.qcby.demo2;

public interface AccountDao {
/**
* 付款
* @param out
* @param money
*/
public void outMoney(String out,double money);
/**
* 收款
* @param in
* @param money
*/
public void inMoney(String in,double money);
}

package com.qcby.demo2;
import org.springframework.jdbc.core.JdbcTemplate;

public class AccountDaoImpl implements AccountDao {
private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
/**
* 付款
* @param out
* @param money
*/
@Override
public void outMoney(String out, double money) {
jdbcTemplate.update("update account set money = money ‐ ? where name = ?",money,out);
}
/**
* 收款
* @param in* @param money
*/
@Override
public void inMoney(String in, double money) {
jdbcTemplate.update("update account set money = money + ? where name = ?",money,in);
}
}

配置文件代码编写

<?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:jdbc.properties" />
<!‐‐加载属性的文件‐‐>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!‐‐配置Jdbc模板类‐‐>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource" />
</bean>
<!‐‐配置service‐‐>
<bean id="accountService" class="cn.tx.demo2.AccountServiceImpl">
<property name="accountDao" ref="accountDao"/>
</bean>
<!‐‐配置dao‐‐>
<bean id="accountDao" class="cn.tx.demo2.AccountDaoImpl">
<property name="jdbcTemplate" ref="jdbcTemplate" />
</bean>
</beans>

测试代码编写

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value = "classpath:applicationContext_dao1.xml")
public class Demo2 {
@Autowired
private AccountService accountService;
/**
* 测试转账的方法
*/
@Test
public void testPay(){
accountService.pay("熊大","熊二",100);
}
}

2. Dao实现类编写的方式（第二种方式）

父类：JdbcDaoSupport（父类中有jdbc模板和连接池的实现）
dao编写

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
/**
* 付款
* @param out
* @param money
*/
@Override
public void outMoney(String out, double money) {
this.getJdbcTemplate().update("update account set money = money ‐ ? where name =
?",money,out);
}
/**
* 收款
* @param in
* @param money
*/
@Override
public void inMoney(String in, double money) {
this.getJdbcTemplate().update("update account set money = money + ? where name =
?",money,in);
}
}

配置文件编写

<?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:jdbc.properties" />
<!‐‐加载属性的文件‐‐>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!‐‐配置Jdbc模板类
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource" />
</bean>
‐‐>
<!‐‐配置service‐‐>
<bean id="accountService" class="cn.tx.demo3.AccountServiceImpl">
<property name="accountDao" ref="accountDao"/>
</bean>
<!‐‐配置dao
<bean id="accountDao" class="cn.tx.demo3.AccountDaoImpl">
<property name="jdbcTemplate" ref="jdbcTemplate" />
</bean>
‐‐>
<bean id="accountDao" class="cn.tx.demo3.AccountDaoImpl">
<property name="dataSource" ref="dataSource" />
</bean>
</beans>

测试方法

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value = "classpath:applicationContext_dao2.xml")
public class Demo3 {
@Autowired
private AccountService accountService;
/**
* 测试转账的方法
*/
@Test
public void testPay(){
accountService.pay("熊大","熊二",100);
}
}

第三章：Spring框架的事务管理

1. Spring框架的事务管理相关的类和API

PlatformTransactionManager接口 – 平台事务管理器。该接口有具体的实现类，根据不同的持久层框架，需要选择不同的实现类！
接口方法如下：

void commit(TransactionStatus status)
void rollback(TransactionStatus status)

如果使用的Spring的JDBC模板或者MyBatis框架，需要选择DataSourceTransactionManager实现类
如果使用的是Hibernate的框架，需要选择HibernateTransactionManager实现类

2. 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
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
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!‐‐使用提供标签的方式‐‐>
<context:property‐placeholder location="classpath:jdbc.properties" />
<!‐‐加载属性的文件‐‐>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!‐‐第一步骤：配置平台事务管理器‐‐>
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
<!‐‐第二步骤：配置事务的通知（没有自己编写切面类，通知方法也不是自己编写，Spring框架提供的）‐‐>
<tx:advice id="txAdvice" transaction‐manager="transactionManager">
<tx:attributes>
<!‐‐对pay进行增强，设置隔离级别，传播行为，超时的时间
REQUIRED属性值值得是两个操作做为一个事务管理
‐‐>
<tx:method name="pay" isolation="DEFAULT" propagation="REQUIRED" />
<tx:method name="find*" read‐only="true" />
</tx:attributes>
</tx:advice>
<!‐‐第三步骤：配置AOP的切面‐‐>
<aop:config>
<!‐‐Spring框架提供系统通知，使用advisor标签‐‐>
<aop:advisor advice‐ref="txAdvice" pointcut="execution(public *cn.tx.demo4.AccountServiceImpl.pay(..))" />
</aop:config>
<!‐‐配置Jdbc模板类
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource" />
</bean>
‐‐>
<!‐‐配置service‐‐>
<bean id="accountService" class="com.qcby.demo3.AccountServiceImpl">
<property name="accountDao" ref="accountDao"/>
</bean>
<!‐‐配置dao
<bean id="accountDao" class="cn.qcby.demo3.AccountDaoImpl">
<property name="jdbcTemplate" ref="jdbcTemplate" />
</bean>
‐‐>
<bean id="accountDao" class="com.qcby.demo3.AccountDaoImpl">
<property name="dataSource" ref="dataSource" />
</bean>
</beans>

配置文件+注解的方式

<?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
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
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring‐tx.xsd">
<!‐‐开启注解的扫描‐‐>
<context:component‐scan base‐package="com.qcby.demo5" />
<!‐‐使用提供标签的方式‐‐>
<context:property‐placeholder location="classpath:jdbc.properties" />
<!‐‐加载属性的文件‐‐>
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"><property name="driverClassName" value="${jdbc.driverClassName}" />
<property name="url" value="${jdbc.url}" />
<property name="username" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!‐‐配置平台事务管理器‐‐>
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
<!‐‐配置Jdbc模板类‐‐>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource" />
</bean>
<!‐‐开启事务注解的支持‐‐>
<tx:annotation‐driven transaction‐manager="transactionManager" />
</beans>

service代码
@Transactional可以加到类上，就是类中所有的方法都开始事务管理；可以加到方法中，那就是此方法开始事务管理

@Service
@Transactional(isolation = Isolation.DEFAULT,propagation = Propagation.REQUIRED)
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
/**
* 转账方法
* @param out 付款人
* @param in 收款人
* @param money 金额
*/
@Override
public void pay(String out, String in, double money) {
// 调用dao方法
accountDao.outMoney(out,money);// 模拟异常
int a = 1/0;
accountDao.inMoney(in,money);
}
}

纯注解的方式

/**
* 配置类
* @author Administrator
*/
@Configuration
@ComponentScan(basePackages="cn.tx.demo6")
@EnableTransactionManagement // 开启事务注解
public class SpringConfig {
/**
* @return
* @throws Exception
*/
@Bean(name="dataSource")
public DataSource createDataSource() throws Exception{
// 创建连接池对象，Spring框架内置了连接池对象
DriverManagerDataSource dataSource = new DriverManagerDataSource();
// 设置4个参数
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql:///spring_db");
dataSource.setUsername("root");
dataSource.setPassword("root");
return dataSource;
}
/**
* 创建模板对象
* @return* @return
*/
@Resource(name="dataSource") // 不仅可以作用在属性上，也可以作用方法上。
@Bean(name="jdbcTemplate") // 把JdbcTemplate保存到IOC容器中
public JdbcTemplate createJdbcTemplate(DataSource dataSource){
JdbcTemplate template = new JdbcTemplate(dataSource);
return template;
}
/**
* 创建平台事务管理器对象
* @param dataSource
* @return
*/
@Resource(name="dataSource")
@Bean(name="transactionManager")
public PlatformTransactionManager createTransactionManager(DataSource dataSource){
DataSourceTransactionManager manager = new
DataSourceTransactionManager(dataSource);
return manager;
}
}
@逾越
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring 学习笔记
qq_44045519的博客
06-12 116
Spring Node 概述 目的: 解决企业应用开发的复杂性 功能: 使用基本的JavaBean代替EJB(Enterprise Service Bus,), 并提供更多的企业应用功能 ESB提供了连接企业内部及跨企业间新的和现有软件应用程序的功能，以一组丰富的功能启用管理和监控应用程序之间的交互。 范围: 任何范围的Java应用 特性 非嵌入式: 基于Spring开发的应用中的对象可以不依赖Spring的API 控制反转(Ioc): 对象由Spring去创建, 不需要程序员去new 依赖注.
spring .net学习 完整 demo four
11-22
"Spring .NET学习 完整 demo four"是一个针对Spring.NET的深入实践教程，旨在帮助开发者全面理解和掌握Spring.NET的核心特性和应用场景。 在这个完整的DEMO中，我们将探讨以下几个关键知识点： 1. **依赖注入...
Spring_four
一杯咖啡
03-31 183
1、Spring JdbcTemlate基本使用 ①导入spring-jdbc和spring-tx 【前者封装着Jdbc的模板对象，后者是事务控制的对象】 ②创建数据库和实体类 ③创建JdbcTemlate对象 ④执行数据操作 导入spring-jdbc和spring-tx <!--c3p0数据库驱动包--> <dependency> ...
Spring Framework
程序员的博客
09-05 916
介绍: Spring Framework核心支持依赖注入，事务管理，Web应用程序，数据访问，消息传递，测试和更多功能。 Spring 官网：https://spring.io/ Spring 文档：https://spring.io/guides Spring Project:https://spring.io/projects 项目快速生成器：https://start.spring.io/ Spring框架为现代基于Java的企业应用程序提供了一个全面的编程和配置模型 - 在任何类...
SpringEL 学习
一路向前
11-26 2194
0，基本信息 1， 官网地址： SpringEL 官网地址 这一块是关于SpringEL的内容 引入jar包： mvnrepository 网址 搜索： spring-expression 不是搜索 SpringEL 会看到： 点击进去，会看到各种版本： 选择一个版本，点击进去 里面会有各种项目的引入方式，比如常见的Maven和Gradle // Maven: <!-- https:...
Spring EL表达式
污萌萌小金鱼的博客
06-22 726
spring-core-4 Spring EL表达式 4.1 介绍 Spring EL表达是一种强大的表达式语言, 可以支持在运行时查询和操作对象.它与EL类似, 但提供了更多扩展功能,如方法调用,字符串模板功能. Spring el表达式支持以下功能: 字面值表达式 boolean和关系操作符 正则表达式 类表达式 访问属性,数组,集合 方法调用 关系运算 调用构造函数 Bean引用 构建数组 内联列表 内联map 三元操作 变量 用户定义函数 集合选择 模板表达式
Spring
qq_69325307的博客
09-01 65
当进行系统功能扩展的时候，如果动了之前稳定的程序，修改了之前的程序，之前所有程序都需要进行重新测试。* 控制反转的实现方式有多种，其中比较重要的叫做：依赖注入(Dependency Injection，简称DI)。反之，如果在扩展系统功能的时候，你修改了之前的代码，那么这个设计是失败的，违背OCP原则。依赖注入：对象A和对象B之间的关系，靠注入的手段来维护。* OCP原则是最核心的，最基本的，其他的六个原则都是为这个原则服务的。注入：是一种手段，通过这种手段，可以让A对象和B对象产生关系。
Spring题库详解
chuige2013的博客
03-13 155
Spring是一个轻量级Java开发框架，最早有Rod Johnson创建，目的是为了解决企业级应用开发的业务逻辑层和其他各层的耦合问题。Spring可以做很多事情，它为企业级开发提供给了丰富的功能，但是这些功能的底层都依赖于它的两个核心特性，也就是依赖注入（dependency injection，DI）和面向切面编程（aspect-oriented programming，AOP）。Spring最根本的使命是解决企业级应用开发的复杂性，即简化Java开发。基于POJO的轻量级和最小侵入性编程；
Spring6老杜【上】
Wolf__king的博客
02-25 433
spring6动力节点老杜
Spring表达式语言（SpEL）
听海边涛声
03-03 975
Spring表达式语言（SpEL）
my-four.rar_four
09-23
【标题】"my-four.rar_four" 是一个包含多种IT学习资源的压缩文件，它整合了不同领域的编程知识，便于学习者系统地掌握相关技术。这个压缩包中的内容涵盖了Java、Web开发、数据库以及文档等多个方面。 【描述】指出...
3、结合spring and propetries1
08-08
在这个例子中，我们扫描了`com.hlj.four.spring`包下的所有bean，但排除了标注为`@Controller`的bean，因为它们通常用于处理HTTP请求，而不是消息队列。同时，我们启用了基于注解的AOP代理，通过`...
Spring Boot in Action
01-18
aims to distill Spring Boot into four main topics: auto-configuration, starter dependencies, the command-line interface, and the Actuator. Along the way, we’ll touch on a few Spring features as ...
spring-four-sample:基于Spring 4框架的示例Web应用程序
05-21
这个"spring-four-sample"项目是一个很好的学习资源，帮助开发者了解如何在实际环境中使用Spring 4。 **核心概念** 1. **依赖注入（Dependency Injection, DI）**：Spring 4的一大核心特性，通过DI容器管理对象...
Vue 3 和 SpringBoot 实现文件分片上传示例
exlink2012的专栏
07-22 373
实现分片上传，并使用Spring Boot在后端保存文件。前端将文件分片并逐个上传到后端，后端接收到所有分片后再进行合并，最终保存为一个完整文件。
OAuth2.0 or Spring Session or 单点登录流程
qq_53374893的博客
07-20 376
一句话精辟解释： 在过滤器放行的时候，偷偷的把原生的 request 和 response 对象换成了它的实现，也就是 调用getSession 的时候拿到的 其实是对redis 操作的Session。但其他的操作还是使用原生的，只不过重写的方法，调用的是子类的，也就是往 redis 里放入 Session，把原生的操作给替换了！分布式Session原理，使用子域名，的时候放入父域名的 JsessionId 然后将这个ID 的所存的内容放入Redis ，这样实现不同域名共享同一sessionID.
Spring纯注解开发
Admans的专栏
07-18 857
Spring3.0引入了纯注解开发的模式，框架的诞生是为了简化开发，那注解开发就是简化再简化。Spring的特性在整合MyBatis方面体现的淋漓尽致哦注解开发前，配置Bean时是在xml里将class分别写在Bean标签里，然后起id，就像这样注解开发后，配置Bean时首先将xml里的标签删掉，然后在类上添加@Component注解即可在xml文件中来写一个扫描包的注解标签，对象就装进IOC容器里了component-scan:component意为组件，scan意为扫描。
SpringBoot整合Elastic-Job 2.1.53版本任务调度，手动任务，动态添加任务演示
最新发布
小哇
07-23 194
zookeeper安装并成功运行。
"旅游管理系统设计与实现：在线平台的挑战与优化
PART FOUR 系统实现 系统实现阶段，我们使用了各种工具和技术来开发和构建系统。其中，我们使用了JDK 1.8、IntelliJ IDEA 2017、Apache Maven 3.5.3和Tomcat 7.0等工具来进行项目构建、开发和管理。通过系统实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值