Spring

最新推荐文章于 2024-05-03 17:35:14 发布
最新推荐文章于 2024-05-03 17:35:14 发布
阅读量78 收藏
点赞数
分类专栏： Spring 文章标签： spring java ioc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rookie__zhou/article/details/113097907
版权

目录

Spring 特点

 1. 提供了IoC容器，方便解耦，简化开发；
 2. 支持AOP，面向切面编程；
 3. 支持声明式事务；
 4. 方便程序的测试；
 5. 方便集成其它框架；

Spring 组织架构

在这里插入图片描述

Spring 核心模块

 1. spring-core：提供了框架的基本组成部分，包括IoC和DI功能；
 2. spring-beans：提供BeanFactory；
 3. spring-context：spring的上下文，即IoC容器；
 4. spring-context-support：提供对第三方集成到spring上下文的支持；
 5. spring-expression：spring表达式语言；

1、Spring IoC

IoC,inverse of control 控制反转。即把原来需要通过 new 关键字创建的对象交由 IoC 容器来管理。

1.1、两种容器

 BeanFactory 和 ApplicationContext；
 ApplicationContext是BeanFactory的子接口，实现了BeanFactory的所有功能，还扩展了其它功能，是一种高级的容器，一般建议使用ApplicationContext。

1.2、ApplicationContext 接口实现

 1. ClassPathXmlApplicationContext***：该容器从XML文件中加载已被定义的bean。不需要提供XML文件的完整路径，会从CLASSPATH中搜索bean配置文件；
 2. FileSystemXmlApplicationContext：需要提供XML文件的完整路径；

1.3、基于XML配置文件的实现过程

1.3.1、添加依赖

<dependencies>
	<!--spring的核心工具包-->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-core</artifactId>
	    <version>5.2.9.RELEASE</version>
	</dependency>
	<!--spring IoC的基础实现，包含访问配置文件、创建和管理bean等-->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-beans</artifactId>
	    <version>5.2.9.RELEASE</version>
	</dependency>
	<!--在基础IoC功能上提供扩展服务，邮件服务、任务调度、远程访问等-->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-context</artifactId>
	    <version>5.2.9.RELEASE</version>
	</dependency>
	<!--spring context的扩展支持-->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-context-support</artifactId>
	    <version>5.2.3.RELEASE</version>
	</dependency>
	<!--spring表达式语言-->
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-expression</artifactId>
	    <version>5.2.9.RELEASE</version>
	</dependency>
	<!--测试工具-->
	<dependency>
	    <groupId>junit</groupId>
	    <artifactId>junit</artifactId>
	    <version>4.12</version>
	</dependency>
</dependencies>

1.3.2、创建配置文件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 id="对象名" class="类的完整路径">
        <property name="属性名" ref="被引用的对象id"></property>
    </bean>
    
</beans>

1.3.3、加载配置文件，获取对象

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Object obj = context.getBean("对象id");

1.4、bean标签的属性

在这里插入图片描述

1.5、对象创建的方式

1.5.1 无参构造

	public StudentDao() {
        System.out.println("使用了无参构造");
    }
    
    <bean id="studentDao" class="com.zhy.dao.StudentDao"></bean>

1.5.2 有参构造

	public StudentDao(String name, int age) {
        System.out.println("使用了有参构造:"+name+","+age);
        this.name = name;
        this.age = age;
    }

	<!--有参构造-->
    <bean id="studentDao1" class="com.zhy.dao.StudentDao">
        <constructor-arg name="name" value="周二宇"></constructor-arg>
        <constructor-arg name="age" value="20"></constructor-arg>
    </bean>

1.5.3 静态方法

	public static void static_method(){
        System.out.println("调用了静态方法");
    }

	<bean id="studentDao2" class="com.zhy.dao.StudentDao" factory-method="static_method"></bean>

1.5.4 非静态方法

	public void no_static_method(){
        System.out.println("调用了非静态方法");
    }

	<bean id="studentDao" class="com.zhy.dao.StudentDao"></bean>
	<bean id="studentDao4" factory-method="no_static_method" factory-bean="studentDao"></bean>

1.6、基于注解的实现过程

1.6.1、配置注解扫描

<!--会扫描指定包及所有子包-->
<context:component-scan base-package="指定扫描的包"></context:component-scan>

1.6.2、注解

 1. 添加在类上
	@Component：表示将类标记为容器中的一个bean； 
	@Service // service层
	@Controller// controller层
	@Repository // dao层
	@Scope(scopeName="singleton") //单例对象
	@Scope(scopeName="prototype") //多例对象
 2. 添加在属性上
	@Value("属性值")
	@Autowired
	@Qualifier("bean name")：一个接口类型同时有两个实现类，@Autowired会报错，使用@Qualifer指定bean；
 3. 添加在方法上
	@PostConstruct：等价于init-method属性；
	@PreDestroy：等价于destroy-method属性；

2、DI

DI，Dependency Injection，即依赖注入。当容器创建bean实例时，将bean实例属性的值注入。

2.1 Set注入

 1. 基本属性类型值
	<property name="" value=""/>
 2. 引用属性类型值
	<property name="" ref="bean id">

注意：类中需要定义set方法。

2.2 构造注入

 1. 通过name属性，按照参数名赋值
	<bean id="StudentDao1" class="com.zhy.dao.StudentDao">
        <constructor-arg name="name" value="周大宇"></constructor-arg>
        <constructor-arg name="age" value="20"></constructor-arg>
    </bean>
 2. 通过index属性，按照参数索引赋值，从0开始
	<bean id="StudentDao2" class="com.zhy.dao.StudentDao">
        <constructor-arg index="0" value="周大宇"></constructor-arg>
        <constructor-arg index="1" value="22"></constructor-arg>
    </bean>
 3. 通过type属性，按照参数类型赋值
	<bean id="StudentDao3" class="com.zhy.dao.StudentDao">
        <constructor-arg type="java.lang.String" value="周三宇"></constructor-arg>
        <constructor-arg type="int" value="24"></constructor-arg>
    </bean>

对应实体类：
	public class StudentDao{
	    private String name;
	    private int age;
    }

2.3 spring el 表达式

<bean id="classDao" class="com.zhy.dao.ClassDao">
    <property name="classId" value="1001"></property>
</bean>

<bean id="studentDao" class="com.zhy.dao.StudentDao" p:classDao-ref="classDao">
    <property name="name" value="周大宇"></property>
    <property name="age" value="20"></property>
    <property name="classDao" value="#{classDao.classId}"></property>
</bean>

2.4 p命名空间

<bean id="studentDao" class="com.zhy.dao.StudentDao" p:name="周大宇" p:age="20"></bean>

2.5 复杂类型

实体类：
public class Demo {
    private Object[] arr;
    private ArrayList list;
    private Set set;
    private Map map;
    private Properties properties;

   setter、getter省略
}

<bean id="studentDao" class="com.zhy.dao.StudentDao"></bean>
<bean id="demo" class="com.zhy.dao.Demo">
    <!--数组-->
    <property name="arr">
        <list>
            <value>数组值1</value>
            <value>数组值2</value>
            <value>数组值3</value>
            <ref bean="studentDao"/>
        </list>
    </property>
    <!--list集合-->
    <property name="list">
        <list>
            <value>list集合值1</value>
            <value>list集合值2</value>
            <value>list集合值3</value>
            <list>
                <value>集合中的集合值1</value>
                <value>集合中的集合值2</value>
                <value>集合中的集合值3</value>
            </list>
            <ref bean="studentDao"></ref>
        </list>
    </property>
    <!--Set-->
    <property name="set">
        <set>
            <value>Set集合值1</value>
            <value>Set集合值2</value>
            <value>Set集合值3</value>
            <ref bean="studentDao"></ref>
        </set>
    </property>
    <!--map-->
    <property name="map">
        <map>
            <entry key="k1" value="v1"></entry>
            <entry key="k2" value="v2"></entry>
            <entry key="k3" value="v3"></entry>
            <entry key="ref" value-ref="studentDao"></entry>
        </map>
    </property>
    <!--properties-->
    <property name="properties">
        <props>
            <prop key="name">周大宇</prop>
            <prop key="password">123456</prop>
        </props>
    </property>
</bean>

2.6 自动注入

<bean id="" class="" autowire=""></bean>

autowire属性：
	no：不自动装配；
	byName：通过name自动装配（属性的名称=bean的id），调取set方法赋值；
	byType：通过类型自动装配（属性的类型=bean的类型），当有多个相同类型的对象时会报错，调取set方法赋值；
	constructor：通过构造方法自动装配（构造方法参数的类型=bean的类型）；

3、AOP

AOP，Aspect Oriented Programming，即面向切面编程。在不改变原程序的基础上为代码段增加新的功能。应用在权限认证、日志、事务。

3.1 JDK动态代理

JDK动态代理，针对实现了接口的类产生代理，代理类实现InvacationHandler接口。

接口：
	public interface JdkService {
	    void login();
	}
实现类：
	public class JdkServiceImpl implements JdkService {
	    @Override
	    public void login() {
	        System.out.println("真实方法执行");
	    }
	}
代理类：
	public class JdkProxy implements InvocationHandler {
	    //目标对象
	    private JdkService target;
	
	    public JdkProxy(JdkService target){
	        this.target = target;
	    }
	
	    @Override
	    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
	        System.out.println("前置增强");
	        //被代理的类
	        Object invoke = method.invoke(target, args);
	        System.out.println("后置增强");
	        return invoke;
	    }
	}
测试：
	@Test
    public void jdkProxyTest(){
        //真实角色
        JdkService jdkService = new JdkServiceImpl();
        //代理角色
        JdkProxy jdkProxy = new JdkProxy(jdkService);
        JdkService service = (JdkService) Proxy.newProxyInstance(jdkService.getClass().getClassLoader(), jdkService.getClass().getInterfaces(), jdkProxy);
        service.login();
    }

3.2 CGLIB动态代理

CGlib动态代理，针对没有实现接口的类产生代理，应用的是底层的字节码增强技术，生成当前类的子类对象，实现MethodInterceptor接口。

添加依赖：
	<dependency>
	    <groupId>cglib</groupId>
	    <artifactId>cglib</artifactId>
	    <version>2.2.2</version>
	</dependency>
普通类：
	public class User {
	    public void login(){
	        System.out.println("真实方法执行");
	    }
	}
代理类：
	public class CglibProxy implements MethodInterceptor {
	    @Override
	    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
	        System.out.println("前置增强");
	        Object obj = methodProxy.invokeSuper(o, objects);
	        System.out.println("后置增强");
	        return obj;
	    }
	}
测试：
	@Test
    public void cglibProxyTest(){
        //真实角色
        User user = new User();
        //代理角色
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(user.getClass());
        enhancer.setCallback(new CglibProxy());
        User u = (User) enhancer.create();
        u.login();
    }

3.3 Spring中使用AOP

aop:before（前置通知）：目标方法运行之前调用；
aop:after-returning（后置通知）：目标方法运行之后调用，出现异常则不会调用；
aop:around（环绕通知）：在目标方法前后调用；
aop:after（最终通知）：目标方法运行之后调用；
aop:after-throwing（异常通知）：程序出现异常时执行；

添加依赖：
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-core</artifactId>
	    <version>5.2.9.RELEASE</version>
	</dependency>
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-beans</artifactId>
	    <version>5.2.9.RELEASE</version>
	</dependency>
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-context</artifactId>
	    <version>5.2.9.RELEASE</version>
	</dependency>
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-context-support</artifactId>
	    <version>5.2.3.RELEASE</version>
	</dependency>
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-aop</artifactId>
	    <version>5.2.9.RELEASE</version>
	</dependency>
	<dependency>
	    <groupId>org.springframework</groupId>
	    <artifactId>spring-aspects</artifactId>
	    <version>5.2.6.RELEASE</version>
	</dependency>
	<dependency>
	    <groupId>org.aspectj</groupId>
	    <artifactId>aspectjweaver</artifactId>
	    <version>1.9.5</version>
	</dependency>
	<dependency>
	    <groupId>aopalliance</groupId>
	    <artifactId>aopalliance</artifactId>
	    <version>1.0</version>
	</dependency>

接口：
	public interface UserDao {
	    void test1();
	}

	public interface UserService {
	    void test1();
	    void test2();
	}
实现类：
	public class UserDaoImpl implements UserDao {
	    @Override
	    public void test1() {
	        System.out.println("UserDaoImpl---test1");
	    }
	}

	public class UserServiceImpl implements UserService {
	
	    private UserDao userDao;
	
	    public void setUserDao(UserDao userDao) {
	        this.userDao = userDao;
	    }
	
	    @Override
	    public void test1() {
	        userDao.test1();
	    }
	
	    @Override
	    public void test2() {
	        System.out.println("UserServiceImpl---test2");
	        int i= 10/0;
	    }
	}
切面：
	public class MyAspect {
	
	    public void before(){
	        System.out.println("前置增强");
	    }
	
	    public void after_returning(){
	        System.out.println("后置增强");
	    }
	
	    public void around(ProceedingJoinPoint point) throws Throwable {
	        System.out.println("环绕增强前");
	        point.proceed();
	        System.out.println("环绕增强后");
	    }
	
	    public void after(){
	        System.out.println("最终增强");
	    }
	
	    public void after_throwing(){
	        System.out.println("异常增强");
	    }
	
	}
配置文件：
	<?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 http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
	
	    <bean id="userDao" class="com.springaop.dao.impl.UserDaoImpl"></bean>
	
	    <bean id="userService" class="com.springaop.service.impl.UserServiceImpl">
	        <property name="userDao" ref="userDao"></property>
	    </bean>
	
	    <bean id="myAspect" class="com.springaop.aspect.MyAspect"></bean>
	
	    <aop:config>
	        <aop:pointcut id="mypoint" expression="execution(* com.springaop.service.impl.*.*(..))"/>
	        <aop:aspect ref="myAspect">
	            <aop:before method="before" pointcut-ref="mypoint"/>
	            <aop:after-returning method="after_returning" pointcut-ref="mypoint"/>
	            <aop:around method="around" pointcut-ref="mypoint"/>
	            <aop:after method="after" pointcut-ref="mypoint"/>
	            <aop:after-throwing method="after_throwing" pointcut-ref="mypoint"/>
	        </aop:aspect>
	    </aop:config>
	
	</beans>
测试类：
	@Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.test1();
        userService.test2();
    }

4、Spring事务管理

Spring的事务和数据库事务基本一致。

4.1 事务的传播行为

在这里插入图片描述
Spring事务传播行为详解

4.1.1 @Transactional属性

在这里插入图片描述

4.1.2 Demo

bean：
	public class Account implements Serializable{
    private Integer id;
    private String name;
    private Float money;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Float getMoney() {
        return money;
    }

    public void setMoney(Float money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" + "id=" + id + ", name='" + name + '\'' + ", money=" + money + '}';
    }
}
dao层：
	public interface AccountDao {
    /**
     * 根据id查找账户信息
     * @param id
     * @return
     */
    Account findAccountById(Integer id);

    /**
     * 根据名称查找账户信息
     * @param name
     * @return
     */
    Account findAccountByName(String name);

    /**
     * 跟新账户信息
     * @param account
     */
    void updateAccount(Account account);
dao实现类：
	public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
    /**
     * 根据id查找账户信息
     *
     * @param id
     * @return
     */
    @Override
    public Account findAccountById(Integer id) {
        String sql = "select * from account where id = ?";
        List<Account> list = getJdbcTemplate().query(sql, new AccountRowMapper(), id);
        return list.isEmpty()?null:list.get(0);
    }

    /**
     * 根据名称查找账户信息
     *
     * @param name
     * @return
     */
    @Override
    public Account findAccountByName(String name) {
        String sql = "select * from account where name = ?";
        List<Account> list = getJdbcTemplate().query(sql, new AccountRowMapper(), name);
        if (list.isEmpty()){
            return null;
        }
        if(list.size()>1){
            throw new RuntimeException("账户不唯一");
        }
        return list.get(0);
    }

    /**
     * 跟新账户信息
     *
     * @param account
     */
    @Override
    public void updateAccount(Account account) {
        String sql = "update account set money=? where id= ?";
        getJdbcTemplate().update(sql,account.getMoney(),account.getId());
    }
}

service层：
	public interface AccountService {

    /**
     * 根据id查找账户信息
     * @param id
     * @return
     */
    Account findAccountById(Integer id);

    /**
     * 转账
     * @param sourceName
     * @param targeName
     * @param money
     */
    void transfer(String sourceName,String targeName,Float money);

}

service层实现类：
	public class AccountServiceImpl implements AccountService {

    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    /**
     * 根据id查找账户信息
     *
     * @param id
     * @return
     */
    @Override
    public Account findAccountById(Integer id) {
        return accountDao.findAccountById(id);
    }

    /**
     * 转账
     *
     * @param sourceName
     * @param targeName
     * @param money
     */
    @Override
    public void transfer(String sourceName, String targeName, Float money) {
        //根据名称查找两个账户
        Account source = accountDao.findAccountByName(sourceName);
        Account targe = accountDao.findAccountByName(targeName);
        //修改两个账户的金额
        source.setMoney(source.getMoney()-money);
        targe.setMoney(targe.getMoney()+money);
        //跟新转账之后的两个账户
        accountDao.updateAccount(source);
        //出现异常
        int i = 10/0;
        accountDao.updateAccount(targe);
    }
}

RowMapper实现类：
	public class AccountRowMapper implements RowMapper<Account> {

    @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.getFloat("money"));
        return account;
    }
}

配置文件：
	<?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:tx="http://www.springframework.org/schema/tx"
	       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 https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
	
	    <!--加载db.properties-->
	    <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
	    <!--配置数据源-->
	    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
	        <property name="driverClassName" value="${driver}"/>
	        <property name="url" value="${url}"/>
	        <property name="username" value="${username}"/>
	        <property name="password" value="${password}"/>
	    </bean>
	    <!--配置jdbcTemplate-->
	    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
	        <property name="dataSource" ref="dataSource"/>
	    </bean>
	
	    <bean id="accountDao" class="dao.impl.AccountDaoImpl">
	        <property name="dataSource" ref="dataSource"></property>
	    </bean>
	    <bean id="accountService" class="service.impl.AccountServiceImpl">
	        <property name="accountDao" ref="accountDao"></property>
	    </bean>
	
	    <!--配置事务管理器-->
	    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	        <property name="dataSource" ref="dataSource"></property>
	    </bean>
	    <!--配置事务-->
	    <tx:advice id="txAdvice" transaction-manager="transactionManager">
	        <tx:attributes>
	            <tx:method name="*" propagation="REQUIRED"/>
	            <tx:method name="find*" propagation="SUPPORTS"/>
	        </tx:attributes>
	    </tx:advice>
	    <!--配置aop-->
	    <aop:config>
	        <aop:pointcut id="pointcut" expression="execution(* service.impl.*.*(..))"/>
	        <aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut"/>
	    </aop:config>
	
	</beans>

测试类：
	public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        AccountService service = (AccountService) context.getBean("accountService");
        service.transfer("周大宇","周二宇",10000f);
    }
}
周大宇_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2024最新首发，全网最全 Spring Boot 学习宝典(附思维导图)
**My Coding Family**
04-20 8万+
从0到1以知识点+实例+项目的教学模式对SpringBoot框架由浅入深进行学习，快来跟bug菌一起学习吧。
《滚雪球学Spring Boot》教程导航帖（更新于2024.03.20）
**My Coding Family**
06-29 3万+
《滚雪球学Spring Boot》教程导航帖，一站式学习！
Spring Boot面试题（2020最新版）
ThinkWon的博客
02-19 56万+
文章目录概述什么是 Spring Boot？Spring Boot 有哪些优点？Spring Boot 的核心注解是哪个？它主要由哪几个注解组成的？配置什么是 JavaConfig？Spring Boot 自动配置原理是什么？你如何理解 Spring Boot 配置加载顺序？什么是 YAML？YAML 配置的优势在哪里 ?Spring Boot 是否可以使用 XML 配置 ?spring boot......
史上最简单的 SpringCloud 教程 | 终章
热门推荐
方志朋的专栏
04-12 197万+
转载请标明出处： http://blog.csdn.net/forezp/article/details/70148833 本文出自方志朋的博客 错过了这一篇，你可能再也学不会 Spring Cloud 了！Spring Boot做为下一代 web 框架，Spring Cloud 作为最新最火的微服务的翘楚，你还有什么理由拒绝。赶快上船吧，老船长带你飞。终章不是最后一篇，它是一个...
Spring Boot源码解读与原理分析
herosunly的博客
10-17 5万+
最近机缘巧合之下，读到了LinkedBear编写的《Spring Boot源码解读与原理分析》这本书，本人花了一周的时间认真研读了一下这本书，真的是受益匪浅，特此推荐给大家，好书不容错过啊。 文章目录 1. 关于作者 2. 本书定位 3. 目标读者 4. 读后感受 5. 书籍特点 6. 总结与展望 LinkedBear是一名资深的Java开发工程师，他倾力研究Spring技术体系多年，对Spring、Spring Boot、MyBatis等框架有独到的见解，拥有丰富的框架体系实践经验和架构封装经验。
springcloud整合nacos配置中心
Venus's Blog
06-07 7万+
如果大家对相关文章感兴趣，可以关注公众号"架构殿堂"，会持续更新AIGC，java基础面试题, netty, spring boot,spring cloud等系列文章，一系列干货随时送达!
完美解决org.mybatis.spring.MyBatisSystemException: nested exception is org.apache.ibatis.reflec
05-15 7万+
org.mybatis.spring.MyBatisSystemException是MyBatis与Spring集成时可能出现的异常，主要原因是在MyBatis的配置或使用过程中出现了问题。解决此异常的方法包括以下步骤：
微服务架构Spring Cloud概述和基本讲解
张彦峰的博客
02-14 164万+
微服务架构Spring Cloud概述和基本讲解
Spring Cloud 微服务项目实战 -
小工匠
11-15 3万+
Milestone 版本：在大版本正式发布前的里程碑版本，例如 2021.0.0-M1，M1 代表当前大版本的第一个里程碑版本，M2 代表第二个迭代里程碑，以此类推。使用模板的好处是可以对优惠券消费规则做一层抽象，比如满减类、打折类这些优惠券只是具体的优惠金额不同，但是玩法类似，把相类似的玩法功能抽象成一个模板，就可以简化具体优惠券的创建和核销流程。建议： 当框架有重大版本更新时，建议你先按兵不动，等大版本做了一两次迭代之后，明显的 Bug 修复得差不多了了，再应用到项目中也不迟。
已解决org.springframework.boot:spring-boot-maven-plugin:
03-26 7万+
org.springframework.boot:spring-boot-maven-plugin 是 Spring Boot 提供的一个 Maven 插件，它用于将 Spring Boot 应用打包成可执行的 JAR 文件或者 WAR 文件。
Spring中文文档下载
09-27
Spring中文文档
spring6pdf详细讲解
09-18
spring6pdf详细讲解
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....
spring源码
10-16
springmvc的源码，采用典型的三层架构进行开发，最简单的增删改查，登陆、修改密码等
SpringBlade开发手册基础版
05-23
SpringBlade开发手册基础版
SpringData JPA - ORM 框架下，打造高效数据访问层
最新发布
CYK_byte的博客
05-03 1093
全英文名叫 Java Persistence API，就是 java 持久化 api ，是SUN公司推出的一套基于 ORM 的规范。ORM（Object Relational Mapping）表示对象关系映射. 简单来讲，通过 ORM，就可以把对象映射到关系型数据库中（为了不用 JDBC 那套方法来操作数据库）.
springboot 获取maven打包时间
I do more ，you do less
04-30 507
【代码】springboot 获取maven打包时间。
springboot整合webflux,mono
qq_19891197的博客
04-30 349
springboot整合webflux,mono
springboot 自动配置源码解读
weixin_46591962的博客
05-01 818
当我们程序依赖第三方功能组件时，不需要手动将这些组件类加载到IOC容器中。例如 当程序需要用到redis时，在pom.xml文件中引入依赖，然后使用依赖注入的方式直接从IOC容器中拿到相应RedisTemplate实例。
spring saml
12-08
Spring Security SAML是Spring Security的一个扩展，它提供了对基于SAML 1.1，2.0和WS-Federation的单点登录（SSO）的支持。它允许您将SAML身份验证和授权集成到Spring Security中，以便您可以使用Spring Security的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值