Spring3~~~

已于 2024-10-09 15:28:25 修改
阅读量656 收藏 10
点赞数 19
分类专栏： Spring 文章标签： java 开发语言
于 2024-09-13 14:22:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_65186476/article/details/142056274
版权

目录

多例

后置处理器BeanPostProcessor

XML配置

 通过注解

AOP与后置处理器

JdbcTemplate

 jdbc.properties

jdbc.xml

Test

添加、修改

查一个对象

 查多个对象

 查一个值

批量添加、修改

具名参数

应用

声明式事务

GoodsDao

GoodsService

xml 

传播机制

​编辑 隔离级别

超时回滚

只读事务

异常回滚

全注解开发

Spring对JUnit的支持

Spring6启用Log4j2日志框架

如果是普通的java项目，xml文件放在src下
如果是java maven项目，xml文件放在resources下

多例

默认情况下，@Component、@Controller、@Service、@Repository是单例的

在Sping1~~~文章中讲解了xml配置单例和多例

@Component
@Scope(value = "prototype")
public class UserAction {}

后置处理器BeanPostProcessor

XML配置

作用在该容器创建的Bean对象

<bean class="spring.bean.MyBeanPostProcessor" 
        id="myBeanPostProcessor"/>

 通过注解

作为一个组件注入到容器中，所以在xml中需要扫描到它才会作用

@Component
public class Process implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }
}

指定init()是初始化方法 
即使不指定初始化方法，后置处理器也会调用postProcessBeforeInitialization

@Component
public class UserService {
    @PostConstruct
    public void init() {}
}

AOP与后置处理器

AOP实现Spring可以给类加上注解：@EnableAspectJAutoProxy

@Component
@EnableAspectJAutoProxy
public class UserDao {}

对Dog进行切面，后置处理器初始化和销毁返回的对象不一样，初始化后切面，变成代理对象

JdbcTemplate

是Spring提供的访问数据库的技术，可以将JDBC的常用操作封装为模板方法

前面的名字可以自己设置

 jdbc.properties

user=root
pwd=123456
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis

jdbc.xml

使用c3p0

    <!--引入外部的jdbc.properties文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    

    <!--配置数据源对象-DataSoruce-->
    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
        <!--给数据源对象配置属性值-->
        <property name="user" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.pwd}"/>
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
    </bean>


    <!--配置JdbcTemplate对象-->
    <bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
        <!--给JdbcTemplate对象配置dataSource-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

可以通过id获取，也可以通过接口获取

Test

增删改都是update

添加、修改

    @Test
    public void t1() throws SQLException {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("jdbc.xml");
        //通过id获取
        //DataSource dataSource = (DataSource)ioc.getBean("dataSource");
        //通过接口获取
        DataSource dataSource = ioc.getBean(DataSource.class);
        Connection connection = dataSource.getConnection();
        connection.close();
        System.out.println(connection);
    }


   //测试通过JdbcTemplate对象完成添加数据
    @Test
    public void addDataByJdbcTemplate() {
        //获取到容器
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("jdbc.xml");

        //获取JdbcTemplate对象
        JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);
        //1. 添加方式1
        //String sql = "INSERT INTO monster VALUES(400, '红孩儿', '枪法')";
        //jdbcTemplate.execute(sql);
        //2. 添加方式2
        String sql = "INSERT INTO monster VALUES(?, ?, ?)";
        //affected表示 执行后表受影响的记录数
        int affected = jdbcTemplate.update(sql, 500, "红孩儿2", "枪法2");
        System.out.println("add ok affected=" + affected);
    }



    //测试通过JdbcTemplate对象完成修改数据
    @Test
    public void updateDataByJdbcTemplate() {

        //获取到容器
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("jdbc.xml");

        //获取JdbcTemplate对象
        JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);

        //组织SQL
        String sql = "UPDATE monster SET skill=? WHERE id=?";
        int affected = jdbcTemplate.update(sql, "美女计", 300);
        System.out.println("update ok affected= " + affected);

    }

查一个对象

    //查询id=100的monster并封装到Monster实体对象[在实际开发中，非常有用]
    @Test
    public void selectDataByJdbcTemplate() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
        //得到JdbcTemplate bean
        JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);
        //组织SQL
        //通过BeanPropertyRowMapper获取rowmapper 是一个接口，可以将查询的结果，封装到你指定的Monster对象中.

        //1. 确定API ： queryForObject()
        //public <T> T queryForObject(String sql, RowMapper<T> rowMapper, @Nullable Object... args)
        //2.准备参数
        String sql = "SELECT id AS monsterId, NAME, skill FROM monster WHERE id = 100";
        //使用RowMapper 接口来对返回的数据，进行一个封装-》底层使用的反射->setter
        //这里有一个细节: 你查询的记录的表的字段需要和 Monster的对象字段名保持一致
        RowMapper<Monster> rowMapper = new BeanPropertyRowMapper<>(Monster.class);
        //jdbcTemplate
        Monster monster = jdbcTemplate.queryForObject(sql, rowMapper);
        System.out.println("monster= " + monster);
        System.out.println("查询ok");

    }

 查多个对象

    @Test
    public void selectMulDataByJdbcTemplate() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
        //得到JdbcTemplate bean
        JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);
        //组织SQL
        //通过BeanPropertyRowMapper获取rowmapper 是一个接口，可以将查询的结果，封装到你指定的Monster对象中.

        //1.    确定API
        //public <T> T query(String sql, RowMapper<T> rowMapper, Object... args){}
        //2. 组织参数
        String sql = "SELECT id AS monsterId, NAME, skill FROM monster WHERE id >= ?";
        RowMapper<Monster> rowMapper = new BeanPropertyRowMapper<>(Monster.class);
        //3. 调用
        List<Monster> monsterList = jdbcTemplate.query(sql, rowMapper, 100);
        for (Monster monster : monsterList) {
            System.out.println("monster= " + monster);
        }
    }

 查一个值

    @Test
    public void selectScalarByJdbcTemplate() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
        //得到JdbcTemplate bean
        JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);

        //1. 确定API
        //public <T> T queryForObject(String sql, Class<T> requiredType)
        //2. 提供参数
        String sql = "SELECT NAME FROM monster WHERE id = 100";
        //Class<T> requiredType 表示你返回的单行单列的数据类型

        String name =
                jdbcTemplate.queryForObject(sql, String.class);
        System.out.println("返回name= " + name);

    }

批量添加、修改

1. 修改多一个参数，删除是batchDelete
2. 使用技巧

        (1) 先确定API名字

        (2) 根据API提供相应的参数 [组织参数]

        (3) 把自己的调用思路清晰

        (4) 根据API, 可以推测类似的用法和功能batch add data
批量添加二个monster 白蛇精和青蛇精-update(sql,List<Object[]>)

     @Test
    public void addBatchDataByJdbcTemplate() {
        ApplicationContext ioc = new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
        //得到JdbcTemplate bean
        JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);//添加..

        //1. 先确定,猜测API名称 batchUpdate
        //public int[] batchUpdate(String sql, List<Object[]> batchArgs){}
        //2. 准备参数
        String sql = "INSERT INTO monster VALUES(?, ?, ?)";
        List<Object[]> batchArgs = new ArrayList<>();
        batchArgs.add(new Object[]{600, "老鼠精", "偷吃粮食"});
        batchArgs.add(new Object[]{700, "老猫精", "抓老鼠"});
        //3. 调用
        //说明：返回结果是一个数组，每个元素对应上面的sql语句对表的影响记录数
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        //输出
        for (int anInt : ints) {
            System.out.println("anInt=" + anInt);
        }
        System.out.println("batch add ok..");
    }

具名参数

xml配置NamedParameterJdbcTemplate对象

    <!--配置NamedParameterJdbcTemplate对象-->
    <bean class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate"
          id="namedParameterJdbcTemplate">
        <!--通过构造器，设置数据源-->
        <constructor-arg name="dataSource" ref="dataSource"/>
    </bean>
    /**
     * 使用Map传入具名参数完成操作，比如添加
     */
    @Test
    public void testDataByNamedParameterJdbcTemplate() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
        //得到NamedParameterJdbcTemplate bean
        NamedParameterJdbcTemplate namedParameterJdbcTemplate =
                ioc.getBean(NamedParameterJdbcTemplate.class);

        //1. 确定使用API
        //public int update(String sql, Map<String, ?> paramMap)
        //2. 准备参数 [:my_id, :name, :skill] 要求按照规定的名字来设置参数
        String sql = "INSERT INTO monster VALUES(:id, :name, :skill)";
        Map<String, Object> paramMap = new HashMap<>();
        //给paramMap填写数据
        paramMap.put("id", 800);
        paramMap.put("name", "蚂蚁精");
        paramMap.put("skill", "喜欢打洞");
        //3. 调用
        int affected = namedParameterJdbcTemplate.update(sql, paramMap);
        System.out.println("add ok affected=" + affected);
    }



//使用sqlparametersoruce 来封装具名参数,还是添加一个Monster 狐狸精

    @Test
    public void operDataBySqlparametersoruce() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");
        //得到NamedParameterJdbcTemplate bean
        NamedParameterJdbcTemplate namedParameterJdbcTemplate =
                ioc.getBean(NamedParameterJdbcTemplate.class);

        //确定API
        //public int update(String sql, SqlParameterSource paramSource)
        //public BeanPropertySqlParameterSource(Object object)
        //准备参数,用对象来传递，应该是对象的属性名
        String sql = "INSERT INTO monster VALUES(:monsterId, :name, :skill)";
        Monster monster = new Monster(900, "大象精", "搬运木头");
        SqlParameterSource sqlParameterSource =
                new BeanPropertySqlParameterSource(monster);
        //调用
        int affected =
                namedParameterJdbcTemplate.update(sql, sqlParameterSource);

        System.out.println("add ok affected= " + affected);
    }

应用

@Repository //将MonsterDao 注入到spring容器
public class MonsterDao {

    //注入一个属性
    @Resource
    private JdbcTemplate jdbcTemplate;

    //完成保存任务
    public void save(Monster monster) {
        //组织sql
        String sql = "INSERT INTO monster VALUES(?,?,?)";
        int affected = jdbcTemplate.update
                (sql, monster.getMonsterId(), monster.getName(), monster.getSkill());
        System.out.println("affected= " + affected);
    }
}



    //测试MonsterDAO
    @Test
    public void monsterDaoSave() {
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("JdbcTemplate_ioc.xml");

        MonsterDao monsterDao = ioc.getBean(MonsterDao.class);
        Monster monster = new Monster(1000, "小鸭精", "吃鱼");
        monsterDao.save(monster);
        System.out.println("MonsterDAO保存 ok ..");
    }

声明式事务

注解方式、xml配置方式

 

@Transactional 注解
     1. 写在Service层的方法或者类上
     2. 即将标识的方法中的，对数据库的操作作为一个事务管理
     3. @Transactional 底层使用的仍然是AOP机制
     4. 底层是使用动态代理对象来调用buyGoodsByTx
     5. 在执行buyGoodsByTx() 方法 先调用 事务管理器的 doBegin() , 调用 buyGoodsByTx()
     如果执行没有发生异常，则调用 事务管理器的 doCommit(), 如果发生异常 调用事务管理器的 doRollback()

传统

声明式事务将每个步骤写成一个方法
各个方法搭配可以组成一个新事务

GoodsDao

@Repository 
public class GoodsDao {

    @Resource
    private JdbcTemplate jdbcTemplate;


    //根据商品id,返回对应的价格
    public Float queryPriceById(Integer id) {
        String sql = "SELECT price From goods Where goods_id=?";
        Float price = jdbcTemplate.queryForObject(sql, Float.class, id);
        return price;
    }


    //修改用户的余额 [减少用户余额]
    public void updateBalance(Integer user_id, Float money) {
        String sql = "UPDATE user_account SET money=money-? Where user_id=?";
        jdbcTemplate.update(sql, money, user_id);
    }

    //修改商品库存 [减少]
    public void updateAmount(Integer goods_id, int amount){
        String sql = "UPDATE goods_amount SET goods_num=goods_num-? Where goods_id=?";
        jdbcTemplate.update(sql, amount , goods_id);
    }


    //根据商品id,返回对应的价格
    public Float queryPriceById2(Integer id) {
        String sql = "SELECT price From goods Where goods_id=?";
        Float price = jdbcTemplate.queryForObject(sql, Float.class, id);
        return price;
    }


    //修改用户的余额 [减少用户余额]
    public void updateBalance2(Integer user_id, Float money) {
        String sql = "UPDATE user_account SET money=money-? Where user_id=?";
        jdbcTemplate.update(sql, money, user_id);
    }

    //修改商品库存 [减少]
    public void updateAmount2(Integer goods_id, int amount){
        String sql = "UPDATE goods_amount SET goods_num=goods_num-? Where goods_id=?";
        jdbcTemplate.update(sql, amount , goods_id);
    }
}

GoodsService

    @Transactional
    public void buyGoodsByTx(int userId, int goodsId, int amount) {
        //1.得到商品的价格
        Float price = goodsDao.queryPriceById(userId);
        //2. 减少用户的余额
        goodsDao.updateBalance(userId, price * amount);
        //3. 减少库存量
        goodsDao.updateAmount(goodsId, amount);
        System.out.println("用户购买成功~");
    }

xml 

    <!--引入外部的jdbc.properties文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    

    <!--配置数据源对象-DataSoruce-->
    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
        <property name="user" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.pwd}"/>
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
    </bean>    


    <!--
    事务管理器
    1. DataSourceTransactionManager 这个对象是进行事务管理
    2. 一定要配置数据源属性，这样指定该事务管理器 是对哪个数据源进行事务控制
    -->
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="transactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>



    <!--
        开启事务注解驱动器
        告诉Spring框架，采用注解的方式去控制事务
    -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

传播机制

在service类中有a()方法和b()方法，a()方法上有事务，b()方法上也有事务，当a()方法执行过程中调用了b()方法，事务是如何传递的？合并到一个事务里？还是开启一个新的事务？这就是事务传播行为。

种类

重点：两种

  • REQUIRED：支持当前事务，如果不存在就新建一个(默认)【没有就新建，有就加入】

       如果有事务在运行，当前的方法就在这个事务内运行，否则，就启动一个新的事务，并在自己的事务内运行

  • REQUIRES_NEW：开启一个新的事务，如果一个事务已经存在，则将这个存在的事务挂起【不管有没有，直接开启一个新事务，开启的新事务和之前的事务不存在嵌套关系，之前事务被挂起】

REQUIRES_NEW是独立的，不受外面的事务影响，如果失败只会回滚当前的事务

REQUIRE是一个整体，只要错误，都不会执行成功

 

 隔离级别

数据库中读取数据存在的三大问题：（三大读问题）

  • 脏读：读取到没有提交到数据库的数据，叫做脏读。
  • 不可重复读：在同一个事务当中，第一次和第二次读取的数据不一样。
  • 幻读：读到的数据是假的。

事务隔离级别包括四个级别：

  • 读未提交：READ_UNCOMMITTED
    • 这种隔离级别，存在脏读问题，所谓的脏读(dirty read)表示能够读取到其它事务未提交的数据。
  • 读提交：READ_COMMITTED
    • 解决了脏读问题，其它事务提交之后才能读到，但存在不可重复读问题。
  • 可重复读：REPEATABLE_READ
    • 解决了不可重复读，可以达到可重复读效果，只要当前事务不结束，读取到的数据一直都是一样的。但存在幻读问题。
  • 序列化：SERIALIZABLE
    • 解决了幻读问题，事务排队执行。不支持并发。

隔离级别

脏读

不可重复读

幻读

读未提交

有

有

有

读提交

无

有

有

可重复读

无

无

有

序列化

无

无

无

修改隔离级别

 @Transactional(isolation = Isolation.READ_COMMITTED)

超时回滚

默认是-1，没有时间限制
超过2s，如果该事务中的所有DML语句（最后一条DML语句及之前所有语句的时间）还没有执行完毕，就会选择回滚

只读事务

 @Transactional(readOnly = true)

启动spring的优化策略，提高select语句执行效率 

异常回滚

 @Transactional(rollbackFor = RuntimeException.class)

出现这个异常以及这个异常的子类异常就回滚 

全注解开发

@Configuration//代替spring.xml配置文件
@ComponentScan("com.powernode.bank")//组件扫描
@EnableTransactionManagement//开始事务注解
public class Spring6Config {

    @Bean(name = "dataSource")
    public DataSource getDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/spring6");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }

    @Bean(name = "jdbcTemplate")
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){
        //spring在调这个方法的时候会自动传递过来一个dataSource对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }

    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
        dataSourceTransactionManager.setDataSource(dataSource);
        return dataSourceTransactionManager;
    }

}
@Test
public void testNoXml(){
    ApplicationContext ioc = new AnnotationConfigApplicationContext(Spring6Config.class);
    AccountService accountService = ioc.getBean("accountService", AccountService.class);
}

Spring对JUnit的支持

以前只是使用依赖，并没有使用支持

        <!--spring对junit的支持相关依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <!--这个版本spring6既支持4，又支持5-->
            <version>6.0.0-M2</version>
        </dependency>
        <!--junit4依赖-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
         <!--junit5依赖-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.9.0</version>
            <scope>test</scope>
        </dependency>

Junit4进行简化 

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring.xml")
public class SpringJUnit4Test {

    @Autowired
    private User user;

    @Test
    public void testUser(){
        System.out.println(user.getName());
    }
}

Junit5进行简化  

@ExtendWith(SpringExtension.class)
@ContextConfiguration("classpath:spring.xml")
public class SpringJUnit5Test {

    @Autowired
    private User user;

    @Test
    public void testUser(){
        System.out.println(user.getName());
    }
}

Spring6启用Log4j2日志框架

使用 

_CYX_
关注
专栏目录
SpringCloud~分布式事务~Seata~AT模式
爪哇人的博客
04-18 1356
1 概述 对于单体服务来说，我们只需要在方法上加上@Transactional注解就可以保证事务的顺利进行，但是对于我们的分布式来说，它涉及到多个服务，服务之间的相互调用没有一个统一的感知，导致了我们某个服务出错了，其他服务的功能有时依然正常进行。所以需要引入分布式事务来保证我们的事务 ，某个服务出错了，相应服务间的调用能够正常进行回滚操作。 seata有好几种模式（AT模式、TCC模式、Saga模式和XA模式），本篇文章讲述seata框架下的AT模式 2 AT模式 Seata开源了......
Spring 6 源码编译教程分享~
1 Byte 的博客
04-01 3693
Spring Boot 3 RELEASE版本于 2022年11月24日 正式发布，此次Spring Boot里程碑的升级也要求了最低JDK 17 和 Spring Framework 6 ，其核心框架的 Spring 也在 2022年11月16日 迎来了从 5.3.x 到 6.0.x 重大版本升级，借着这个机会，写一篇关于 Spring 6 源码编译的教程分享。
专题二：Spring源码编译
Jeremy程序员
06-29 11万+
Spring 源码配置：1、下载源码 2、配置Gradle 3、源码配置文件修改
深入浅出 Spring Boot 3.x：从原理到实战，全面解锁 Java 后端开发新潮流
努力是为了站在万人之中，成为别人的光
04-25 4万+
Spring框架是Java EE开发的强有力的工具和事实标准，而Spring Boot采用“约定优于配置”的原则简化 Spring的开发，成为业界流行的微服务开发框架，被越来越多的企业采用。为了适应新潮流，本书对Spring Boot 3.x技术进行深入讲解。
简述Spring、SpringMvc和SpringBoot的区别
王小二(海阔天空)
04-11 9万+
SpringBoot：简述SpringBoot和Spring的区别 一、Spring的介绍    简而言之，Spring框架为开发Java应用程序提供了全面的基础架构支持。 它包含一些很好的功能，如依赖注入和开箱即用的模块，如： Spring JDBC Spring MVC Spring Security Spring AOP Spring ORM Spring ...
SpringCloud入门教程（全集）
tttalk的博客
03-01 9万+
SpringCloud所有常见组件介绍及使用示例
Spring系列一：spring的安装与使用
你好, 我在学java的博客
07-24 8686
Spring框架学习[上 50%]
spring cloud学习资料~持续更新
lsziri的专栏
03-03 2247
官方网站http://projects.spring.io/spring-cloud/中文资料网https://springcloud.cc/ http://bbs.springcloud.cn/ http://docs.springcloud.cn/项目地址https://github.com/spring-cloud书本https://github.com/eacdy/spring-clou
Spring Cloud 从入门到精通
热门推荐
GitChat
07-03 79万+
Spring Cloud 是一套完整的微服务解决方案，基于 Spring Boot 框架，准确的说，它不是一个框架，而是一个大的容器，它将市面上较好的微服务框架集成进来，从而简化了开发者的代码量。 本课程由浅入深带领大家一步步攻克 Spring Cloud 各大模块，接着通过一个实例带领大家了解大型分布式微服务架构的搭建过程，最后深入源码加深对它的了解。 本课程共分为四个部分： 第一部分（第...
Spring Boot 3.x快速入门
laopeng301的专栏
04-21 1万+
Spring Boot 3 简介 Spring Boot帮助你创建独立的、生产级的基于Spring的应用程序。大多数Spring Boot应用程序只需要很少的Spring配置。 主要目标有： 为所有Spring开发者提供一种快速的入门体验 做到开箱即用 提供大量非功能性特性相关项目（例如：内嵌服务器、安全、指标、健康检查、外部配置) 无代码生成、无需编写XML 系统环境要求 Spring Boot 3.0.0 需要 Java 17. 还需要Spring Framework 6.0.0-M2 及以上版本。
Spring+3.x企业应用开发实战光盘源码(全)
03-27
　第3章：讲解Spring IoC容器的知识，通过具体的实例详细地讲解IoC概念。同时，对Spring框架的三个最重要的框架级接口进行了剖析，并对Bean的生命周期进行讲解。 　第4章：讲解如何在Spring配置文件中使用Spring 3.0...
spring3+security3+struts2开源权限项目
05-09
【标题】"spring3+security3+struts2开源权限项目"揭示了这是一个结合了Spring 3、Spring Security 3和Struts 2框架的开源权限管理解决方案。它旨在为开发者提供一个完整的、基于角色的访问控制（RBAC）结构，以实现...
springcloud~服务发现之k8s服务
m0_66876551的博客
04-24 1921
springboot开发微服务框架一般使用springcloud全家桶，而整个项目都是容器化的，通过k8s进行编排，而k8s自己也有服务发现机制，所以我们也可以抛弃springcloud里的eureka，而直接使用k8s自己的服务。 添加组件 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId>spring-cloud-starter-netflix-ribbo
spring security原理和机制 | Spring Boot 35
学Java，找哪吒
06-25 5万+
一、SpringSecurity 框架简介 Spring 是非常流行和成功的 Java 应用开发框架，Spring Security 正是 Spring 家族中的 成员。Spring Security 基于 Spring 框架，提供了一套 Web 应用安全性的完整解决方 案。 正如你可能知道的关于安全方面的两个主要区域是“认证”和“授权”（或者访问控 制），一般来说，Web 应用的安全性包括用户认证（Authentication）和用户授权 （Authorization）两个部分，这两点也是 Spring
springcloud整合dubbo3使用nacos作为注册中心
congge
05-05 6360
springcloud整合dubbo3使用nacos作为注册中心
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 377
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 679
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
确保Spring Boot定时任务只执行一次方案
2301_76419561的博客
10-14 458
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
SpringBoot智能物流管理系统开发指南
最新发布
2401_85762266的博客
10-18 787
在概念模式的设计中，E-R模型法是最常见的设计方法。B/S架构的运行方式是在远程的服务器上把开发的软件系统部署在远程的服务器上，在部署好软件系统之后就可以实现在任何接入互联网的电脑上访问部署好的软件系统。6、网络上的客户端和服务器可以用来编程任何独立的编程环境，也有中国，GB2312，BIG5，日文写作，一般基金，用于支持多国语言，并且可以嵌入在数据表和其他软件shift_jis访问柱可以用作的名称。编程语言，如C, C ++，Python和Java的，的Perl，PHP，埃菲尔铁塔，Ruby和Tcl的。
"跟我学Spring3：深入理解IoC、DI、AOP和JDBC支持
Spring3是一个非常受欢迎的Java框架，本课程将深入了解Spring3的关键知识点，共分为七章，每一章都是构建在前一章的基础之上，让学习者能够逐步掌握Spring3的核心概念和技术。 第一章是关于Spring概述的内容，通过...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值