Spring5学习（尚硅谷）

最新推荐文章于 2022-08-01 22:41:53 发布
最新推荐文章于 2022-08-01 22:41:53 发布
阅读量998 收藏 3
点赞数 1
文章标签： spring java eureka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Charles__ma/article/details/122479212
版权

1.Spring概念

1.Spring是轻量级开源的JavaEE框架

2.Spring可以解决企业应用开发的复杂性

3.Spring有两个核心部分：IOC和Aop

（1）IOC：控制反转，把创建对象过程交给Spring进行管理。

（2）Aop：面向切面，不修改源代码的进行功能增强。

4.Spring特点

(1)方便解耦，简化开发

(2)Aop编程支持

(3)方便程序测试

(4)方便和其他框架进行整合

(5)事务管理，降低api开发难度

<!--Spring核心基础依赖-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>5.3.9</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.3.9</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>5.3.9</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>5.3.9</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>5.3.9</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>5.3.9</version>
    </dependency>

<?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">
    <!--把testDao对象的创建权交给Spring-->
    <bean id="user" class="org.example.dao.User"></bean>
</beans>
//1.加载spring的配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
        //2.获取配置创建的对象
        User user = context.getBean("user", User.class);
        System.out.println(user);
        user.add();

2.IOC容器

(1) IOC底层原理

IOC(概念和原理)

1.什么是IOC。

(1)控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理。

(2)使用IOC的目的：为了耦合度的降低。

耦合度的理解：两个实体类之间的关系

2.IOC底层原理

xml解析、工厂模式、反射。

<bean id="dao" class="com.example.UserDao"></bean>
​
Class UserFactory{
    public static UserDao getDao(){
        String classValue = class属性值; //xml解析
        Class class = Class.forName(classValue); //通过反射创建对象
        return (UserDao)class.newInstance;
    }
}

(2) IOC接口（BeanFactory）

1.IOC思想基于IOC容器完成，IOC容器底层就是对象工厂。

2.Spring提供IOC容器

(1).BeanFactory:IOC容器基本实现，是Spring内部的使用接口，开发一般不适用。

(2) ApplicationContext:BeanFactory接口的子接口 ，提供更多更强大的功能，一般由开发人员进行使用。

区别：BeanFactory加载配置文件时候不会创建对象，在获取对象才会去创建对象。ApplicationContext加载配置文件时候就会把在配置文件的对象进行创建

3.ApplicationContext接口

##### 1.什么是Bean管理
​
(1)Spring创建对象
​
(2)Spring注入属性
​
##### 2.Bean管理操作有两种方式
​
(1)基于xml方式实现
​
(2)基于注解方式实现

(3)IOC操作Bean管理（基于xml）

1.创建对象

<?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">
    <!--把testDao对象的创建权交给Spring-->
    <bean id="user" class="org.example.dao.User"></bean>
</beans>

ps：创建对象时，默认执行无参数的构造方法

设置空值

 

特殊符号解决

 

2.注入属性

(1)DI:依赖注入，就是注入属性。

<!--set方法注入属性-->
    <bean id="book" class="org.example.pojo.Book">
        <property name="name" value="abc"></property>
        <property name="author" value="Chalres"></property>
    </bean>
<!--有参构造属性-->
    <bean id="order" class="org.example.pojo.Orders">
        <constructor-arg name="name" value="电脑"></constructor-arg>
        <constructor-arg name="address" value="China"></constructor-arg>
    </bean>

还可以用index代替name，代表有参构造的第i个参数。

p名称空间（了解即可）

注入属性-内部bean和级联赋值

<bean id="emp" class="org.example.pojo.Emp">
        <property name="name" value="loucy"></property>
        <property name="gender" value="女"></property>
        <!-- 在内部嵌套对象注入   -->
        <property name="dept">
            <bean id="dept" class="org.example.pojo.Dept">
                <property name="name" value="安保部"></property>
            </bean>
        </property>
    </bean>
<bean id="emp" class="org.example.pojo.Emp">
        <property name="name" value="loucy"></property>
        <property name="gender" value="女"></property>
        <!-- 在内部嵌套对象注入   -->
        <property name="dept" ref="dept">
        </property>
    </bean>
    <bean id="dept" class="org.example.pojo.Dept">
        <property name="name" value="安保部"></property>
    </bean>

注入集合

 <property name="list">
            <list>
                <value>张三</value>
                <value>小三</value>
            </list>
        </property>

集合注入部分提取出来

1.在spring配置文件中引入名称空间util

1.Spring有两种类型bean，一种普通类型bean，另一种是工厂bean(Factory bean)

普通bean：在配置文件中定义bean类型就是返回类型。

工厂bean：在配置文件定义bean类型可以和返回类型不一样

（1）创建类，让这个类作为工厂bean，实现接口FactoryBean

（2）实现接口里面的方法，并定义返回bean类型。

public class MyBean implements FactoryBean<Course> {
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCname("abc");
        return course;
    }
​
    @Override
    public Class<?> getObjectType() {
        return null;
    }
​
    @Override
    public boolean isSingleton() {
        return false;
    }
}

bean的作用域

1.在Spring里面，默认情况下，bean是单实例对象，即从ApplicationContext获得的一直是一样地址的对象

<bean id="myBean" class="org.example.factorybean.MyBean" scope="prototype"></bean>

2.singleton和prototype区别

第一、singleton单实例，prototype多实例

第二、设置singleton环境时，加载spring配置文件时就会创建单实例对象。设置prototype时候，不是在加载spring配置文件时候创建对象，在调用getBean方法时候创建多实例对象

3.bean生命周期(bean后置处理器)

(1)通过构造器创建bean实例（无参数构造）

(2)为bean的属性设置值和对其他bean引用（调用set方法）

把bean实例传递bean后置处理器的方法

(3)调用bean的初始化方法(需要进行配置初始化的方法)

把bean实例传递bean后置处理器的方法

(4)bean可以使用了（对象获取到了）

(5)当容器关闭时候，调用bean的销毁方法(需要配置销毁方法)

xml自动装配

1.什么是自动装配:根据指定装配规则，Spring自动将匹配的属性值进行注入。

<bean id="emp" class="org.example.pojo.Emp" autowire="byName">
    </bean>
    <bean id="dept" class="org.example.pojo.Dept"></bean>

引入外部属性文件配置数据库连接池

<context:property-placeholder location="jdbc.properties"/>
        <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <property name="driverClassName" value="${prop.driverClass}"></property>
            <property name="url" value="${prop.url}"></property>
            <property name="username" value="${prop.userName}"></property>
            <property name="password" value="${prop.password}"></property>
        </bean>

在spring配置文件中引入配置文件信息

(4)IOC操作Bean管理（基于注解）

1.使用注解的目的：简化xml配置

2.Spring针对Bean管理中创建对象提供注解

@Component

@Service

@Controller

@Repository

基于注解方式的对象创建

1.引入依赖

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>5.3.9</version>
    </dependency>

2.组件扫描

<context:component-scan base-package="org.example"></context:component-scan>

use-default-filters:可以设置是否使用默认的扫描器

3.添加注解

基于注解的属性注入

1.@AutoWired

根据属性类型进行自动装配

2.@Qualifier

根据属性名称进行注入，要和上面@Autowired一起使用，可以具体指定注入哪个类型的属性

3.@Resource

可以根据属性类型进行自动装配，也可以根据属性名称进行注入。

4.@Value

可以注入普通类型的值

完全注解开发

1.创建配置类

2.加载配置类

@Configuration          //作为配置类，替代xml文件
@ComponentScan(basePackages = {"org.example"})
public class SpringConfig {
}

3.Aop

1.概念

面向切面编程（方面），利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高开发效率。

通俗描述：不通过修改源代码方式添加新的功能，在主干功能里面添加新功能。

2.底层原理

1.AOP底层使用动态代理

代理的理解:Proxy代理模式是一种结构型设计模式，主要解决的问题是：在直接访问对象时带来的问题
代理是一种常用的设计模式，其目的就是为其他对象提供一个代理以控制对某个对象的访问。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理。
​
更通俗的说，代理解决的问题当两个类需要通信时，引入第三方代理类，将两个类的关系解耦，让我们只了解代理类即可，而且代理的出现还可以让我们完成与另一个类之间的关系的统一管理，但是切记，代理类和委托类要实现相同的接口，因为代理真正调用的还是委托类的方法。
按照代理的创建时期，代理类可以分为两种： 
​
静态：由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。
​
动态：在程序运行时运用反射机制动态创建而成。

(1)有两种情况的动态代理。

第一种，有接口的情况，使用jdk动态代理。

创建接口实现类代理对象，增强类的方法。

 

第二种 没有接口情况，使用CGLIB动态代理

创建子类的代理对象，增强类的方法

2.实操

1.jdk动态代理，使用Proxy里面的方法

调用newProxyInstance方法

public class App 
{
    public static void main( String[] args )
    {
        //创建接口实现类代理对象
        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao = (UserDao) Proxy.newProxyInstance(App.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int result = dao.add(1,2);
        System.out.println(result);
    }
}
​
class UserDaoProxy implements InvocationHandler{
​
    //增强的逻辑
    private Object obj;
    public UserDaoProxy(Object obj) {
        this.obj=obj;
    }
​
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
​
        //方法之前
        System.out.println("方法之前执行"+method.getName()+" :传递的参数..."+ Arrays.toString(args));
        //被增强的方法执行
        Object res = method.invoke(obj, args);
        //方法之后
        System.out.println("方法之后执行"+obj);
        return res;
    }
}

AOP术语

连接点:类里面可以增强的方法。

切入点：实际被真正增强的方法

通知(增强):

1.实际增强的逻辑部分称为通知

2.前置通知，后置通知，环绕通知，异常通知，最终通知

切面：把通知应用到切入点

AOP操作

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>5.2.7.RELEASE</version>
    </dependency>
​
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjtools</artifactId>
      <version>1.9.5</version>
    </dependency>
​
    <dependency>
      <groupId>aopalliance</groupId>
      <artifactId>aopalliance</artifactId>
      <version>1.0</version>
    </dependency>
​
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.0</version>
    </dependency>
​
    <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>3.3.0</version>
    </dependency>

1.Spring框架一般是基于AspectJ实现AOP操作

(1)ASpectJ不是Spring组成部分，独立AOP框架，一般将AspectJ和Spring框架一起使用进行AOP操作

2.切入点表达式

作用：知道对哪个类里面的方法进行增强

execution(* com,atguigu.dao.BookDao.*(..)) //星号表示任意

3.AOP操作（AspectJ注解）

1.在spring配置文件中，开启注解扫描

//可以直接用配置类实现
@Configuration
@ComponentScan(basePackages={"com.atiguigu"}
@EnableAspectJAutoProxy(proxyTargetClass=ture)
public class ConfigAop{
    
}

2.使用注解创建User和UserProxy对象

3.在增强类上添加注解@Aspect

4.在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:util="http://www.springframework.org/schema/util"
       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/util http://www.springframework.org/schema/util/spring-util.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:component-scan base-package="org.example.aopanno"></context:component-scan>
    <!--开启AspectJ生成代理对象 -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>
@Component
@Aspect
public class UserProxy {
​
    //前置通知
    @Before(value = "execution(* org.example.aopanno.User.add(..))")
    public void before(){
        System.out.println("before");
    }
​
    @After(value = "execution(* org.example.aopanno.User.add(..))")
    public void after(){
        System.out.println("after......");
    }
​
    @AfterReturning(value = "execution(* org.example.aopanno.User.add(..))")
    public void afterreturn(){
        System.out.println("afterReturning......");
    }
​
    @AfterThrowing(value = "execution(* org.example.aopanno.User.add(..))")
    public void afterThrowing(){
        System.out.println("afterThrowing");
    }
​
    @Around(value = "execution(* org.example.aopanno.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable{
        System.out.println("环绕之前");
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后");
    }
​
}

有多个增强类对同一个方法进行增强，设置增强类的优先级

用@Order注解来设置优先级

4.AOP操作（AspectJ配置文件）

了解即可，一般不用

<bean id="book" class="org.example.aopxml.Book"></bean>
    <bean id="bookProxy" class="org.example.aopxml.BookProxy"></bean>
​
    <!--配置aop增强-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="p" expression="execution(* org.example.aopxml.Book.buy(..))"/>
        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <aop:before method="before" pointcut-ref="p"/>
        </aop:aspect>
    </aop:config>

4.JdbcTemplate

1.概念和准备

什么是jdbcTemplate

spring框架对JDBC进行封装，方便对数据库进行操作

操作

1.导入依赖

 

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.3.9</version>
    </dependency>
​
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-orm</artifactId>
      <version>5.3.9</version>
    </dependency>
​
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.3.9</version>
    </dependency>

2.在spring配置文件配置数据库连接池

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

3.配置jdbcTemplate对象，注入DataSource

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

4.通过jdbcTemplate在dao层操作数据库

@Repository
public class BookDaoImpl implements BookDao{
​
    @Autowired
    private JdbcTemplate jdbcTemplate;
​
    @Override
    public void add(Book book) {
        //1.创建sql语句
        String sql = "insert into t_book values(?,?,?)";
        //2.调用方法实现
        int update = jdbcTemplate.update(sql, book.getUserId(), book.getUsername(), book.getUstatus());
        System.out.println(update);  //返回更新的数据条数
    }
}

JdbcTemplate操作数据库

query过程都可以进行数据类型自动转换，而且不仅仅按标准命名，还可以支持下划线分隔后拼接成驼峰式字符
完全轻量级.
BeanPropertyRowMapper/ParameterizedBeanPropertyRowMapper ，如果PO和数据库模型的字段完全对应（字段名字一样或者驼峰式与下划线式对应），如果使用JdbcTemplate则可以使用这个RowMapper作为PO和数据库的映射
Spring 2.5 提供了一个便利的RowMapper实现-----BeanPropertyRowMapper
它可自动将一行数据映射到指定类的实例中 它首先将这个类实例化，然后通过名称匹配的方式，映射到属性中去。
BeanPropertyRowMapper是根据字段名和实体类中的标准Setter方法进行映射滴。也就是说，我们需要使表中的字段名和实体类的成员变量名称一致。

jdbc进行批量操作

@Override
    public void batchAddBook(List<Object[]> batchArgs) {
        String sql="insert into t_book values(?,?,?)";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

5.事务管理

事务概念

1.什么是事务

事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操作都失败，典型场景：银行转账

2.事务的四个特性(ACID)

1.原子性

2.一致性

3.隔离性

4.持久性

搭建事务操作环境

参考之前写的dao层，service层代码，注意注解和代理类

具体操作

1.事务添加到JavaEE三层结构里面的Service层

2.有两种方式：编程式事务管理和声明式事务管理

3.声明式事务管理

1.基于注解方式

2.基于xml配置文件方式

4.Spring进行声明式事务管理，底层使用AOP原理

5.Spring事务管理API

提供一个接口，代表事务管理器，这个接口针对不同框架提供不同实现类

事务操作（注解）

1.在spring配置文件配置事务管理器

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

2.引入名称空间tx，开启注解

<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

3.在service类上添加注解 @Transactional

如果检测到了异常，事件会还原到原来的状态

事务传播行为(propagation)：

什么叫事务传播行为？听起来挺高端的，其实很简单。 即然是传播，那么至少有两个东西，才可以发生传播。单体不存在传播这个行为。

事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。 例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个新事务运行，这就是由methodB的事务传播行为决定的 img

事务方法：对数据库数据进行变化的操作

事务隔离级别(isolation)

1.事务有特性成为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题。

2.三个读问题：脏读，不可重复读，虚（幻）读

主要关注脏读

脏读：脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。

事务操作（XML声明式）

<!--1.配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
​
    <!--2.配置通知-->
    <tx:advice id="txadvice">
        <tx:attributes>
            <tx:method name="accountMoney" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
​
    <!--3.配置切入点和切面-->
    <aop:config>
        <aop:pointcut id="pt" expression="execution(* org.example.service.UserService.*(..))"/>
        <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
    </aop:config>

事务操作（完全注解开发）

用配置类代替xml配置文件

@Configuration
@ComponentScan(basePackages = "org.example")
@EnableTransactionManagement
public class TxConfig {
​
​
    //创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        druidDataSource.setUrl("jdbc:mysql://localhost:3306/userdb");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("admin");
        return druidDataSource;
​
    }
​
    @Bean
    //创建jdbc模板对象,注意这里用datasource作为参数，意思是通过类型自动注入属性，因为ioc容器中已经有了datasource的实例
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        jdbcTemplate.setDataSource(dataSource);
        return  jdbcTemplate;
    }
​
    @Bean
    //创建事务管理器
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager=new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

6.Spring5新特性

Charles12138丶
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MyBatis(尚硅谷)
qq_57216731的博客
10-04 497
建议分成两种情况进行处理实体类类型的参数使用@Param标识参数resultMap：设置自定义映射属性：id：表示自定义映射的唯一标识，不能重复type：查询的数据要映射的实体类的类型子标签：id：设置主键的映射关系result：设置普通字段的映射关系子标签属性：property：设置映射关系中实体类中的属性名column：设置映射关系中表中的字段名。
尚硅谷-Spring5学习笔记
bigqiangwu的博客
09-07 1131
尚硅谷-Spring5学习笔记，纯手敲。忘记了，可以随时浏览。
尚硅谷_Spring5
Hello_super的博客
08-01 531
Spring5概述 | IOC | AOP | JDBCTemplate | Spring5新特性 |完全注解开发
spring5应用 看这一篇就够了！（参考尚硅谷）
xiao_yan_的博客
08-24 515
spring5框架spring框架搭建（准备工作）spring框架jar包下载spring框架使用1.Spring5 框架概述入门案例包结构代码展示及详解IOC（概念和原理）1、什么是 IOC [具体细节看这里](https://www.jianshu.com/p/17b66e6390fd)2、IOC 底层原理3、Aop4、JdbcTemplate5、事务管理6、Spring5 新特性 spring框架搭建（准备工作） spring框架jar包下载 jar下载链接 我所使用的是5.2.6，如果需要其他版本
尚硅谷Spring5框架笔记总结P1-P3
weixin_54679797的博客
06-08 315
视频地址：尚硅谷Spring框架视频教程（spring5源码级讲解）_哔哩哔哩_bilibili1、Spring概念2、IOC容器3、Aop4、JdbcTemplate5、事务管理6、Spring5里的新特性1、Spring是轻量级的开源的JavaEE框架2、Spring可以解决企业应用开发的复杂性3、Spring有两个核心部分：IOC和Aop(1)IOC：控制反转，把创建对象的过程用Spring进行管理(2)Aop：面向切面，不修改源代码进行功能增强4.Spring特点：（1）方便解耦，简化开发（2）Ao
尚硅谷Spring6的笔记
02-02
尚硅谷Spring6的笔记
尚硅谷spring学习源码
01-19
尚硅谷spring学习源码，自己学习一点一点敲的，非常详细的注释和理解
尚硅谷Spring4视频教程
07-18
尚硅谷Spring4视频教程，仅供参考学习，有需要的可以下载，本人有全栈开发工程师各种技术视频教程及本档，有需要的可以留言或到本人账号下载
尚硅谷Spring笔记
04-11
尚硅谷Spring笔记
尚硅谷spring4视频教程
07-10
本视频是尚硅谷spring4框架教程，内容基础适合有一定Javaweb基础的学习
尚硅谷周阳老师SpringCloud学习源码
08-31
该资源为尚硅谷周阳老师SpringCloud学习的所有模块源码
尚硅谷2020最新SpringCloud思维导图【第二季】（非官方版本，个人学习笔记）
05-26
个人学习过程中，从视频中摘录的，自认为是目前网上最好、最全的版本了。 我的开发环境是在Mac上，所以有个别地方和周阳老师不一样，但是我都会在备注中同时注明了周阳老师Windows的原版话术。 除个别视频中没有展开的内容，其他内容只多不少，还原度高达99%。 周阳老师思路清晰，整体贯穿讲下来值得大家学习和参考。我是老程序员，所以是开1.5到2的倍速看下来的，但是为了整理笔记确实也耗费了不少时间和精力。 配套的源码：https://github.com/wenren0819/Spring-Cloud-2020 分享出来目的不是骗分儿，是希望能够帮助到大家，
尚硅谷SpringBoot视频全套(核心技术篇+整合篇)
05-30
SpringBoot是企业级开发的整体整合解决方案，特别用于快速构建微服务应用，旨在用简单的方式让开发人员适应各种开发场景； 本视频着重介绍SpringBoot的使用和内部原理；内容包含微服务概念、配置文件、日志框架的使用、web开发、Thymeleaf模板引擎、Docker容器技术、MyBatis、Spring Data JPA、自定义starter等； 着重介绍SpringBoot的与各大场景的整合使用，内容包括：缓存（整合Redis），消息中间件（整合RabbitMQ），检索（整合ElasticSearch），任务（异步任务，定时任务，邮件任务），安全（整合SpringSecurity），分布式（整合Zookeeper/dubbo，整合SpringCloud），SpringBoot应用监管； 学习本套视频需要掌握SpringBoot；对于其他技术，视频包含快速入门讲解；
java spring视频5
09-27
java spring视频5
（尚硅谷）2020 版 Spring5 教程笔记
qq_42148002的博客
06-09 1551
由于版本不一致，老师的下载过程和我们的也不太一样，这里本人参考了Spring下载教程，如果使用 maven 的话，可以直接跳过下载 Spring 这一步，但是我们需要知道目前发布的最稳定的 Spring 框架版本是多少。这里老师讲解了最原始的创建 Spring 项目的方法，不过既然学了 maven 的话，就不用自己导包，太麻烦了；而且老师在创建过程中貌似没有使用 module，新讲一块儿内容就创建一个 project，属实是 eclipse 的玩儿法了。 在我们的 pom.xml 文件中配置，这里为了后
spring5学习笔记--spring概述
XiaoLongFight的博客
06-04 1316
Spring5概述：spring 是一个开源的轻量级JavaSE(Java 标准版)/Java EE(企业版)开发应用框架，其目的用于简化企业级应用程序开发。spring帮我们管理对象及其依赖关系，还提供了像日志记录，性能统计，安全控制，异常处理等面向切面的能力，还帮我们管理最头痛的数据库事务，本身提供了一套简单的JDBC访问实现，提供了与第三方数据访问框架集成（如：Hibernate,JPA）,...
Spring5学习（五）Spring DAO
zm的博客
02-26 304
Spring DAO Spring对数据访问对象（DAO）的支持旨在使以一致的方式轻松使用数据访问技术（例如JDBC，Hibernate或JPA）。这使您可以轻松地在上述持久性技术之间进行切换，还使您无需担心捕获每种技术特有的异常即可进行编码。 1. 使用JDBC访问数据库 使用JdbcTemplate模板类操作数据 JdbcTemplate主要提供以下五类方法： execute方法：可以...
Spring5学习
qq_40088655的博客
05-15 250
Spring5的学习内容分享
Spring5学习笔记
张仅爱JAVA
10-13 338
Spring5 框架 课程内容介绍 1、Spring 框架概述 2、IOC 容器 （1）IOC 底层原理 （2）IOC 接口（BeanFactory） （3）IOC 操作 Bean 管理（基于 xml） （4）IOC 操作 Bean 管理（基于注解） 3、Aop 4、JdbcTemplate 5、事务管理 6、Spring5 新特性 Spring5 框架概述 1、Spring 是轻量级的开源的 JavaEE ...
springcloud尚硅谷
最新发布
07-27
Spring Cloud是一个用于构建分布式系统的开发工具集合，它基于Spring Boot构建，提供了一套简化的开发模型和通用的...通过学习尚硅谷的Spring Cloud课程，可以帮助开发者快速上手并应用Spring Cloud来构建分布式系统。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值