Spring5知识点简要梳理

最新推荐文章于 2022-04-08 20:58:45 发布
最新推荐文章于 2022-04-08 20:58:45 发布
阅读量128 收藏
点赞数
分类专栏： 框架 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53469830/article/details/123700159
版权

在这里插入图片描述

IOC-XML

创建对象

<bean id="book" class="bean.Book"></bean>

  • 在spring配置文件中，使用bean标签，在标签中添加对应属性，就可以实现对象创建

  • bean标签中的属性

    • id属性：相当于给类起别名，作为唯一标识
    • class属性：要创建的对象所属类的全路径（包路径）
    • name属性（不用）：等同于id，区别在于name中可以加特殊符号

  • 创建对象的时候，默认执行无参构造方法

注入属性

使用set方法注入（需要生成对应set方法）

<!--配置对象的创建，使用set方法注入属性-->
<bean id="book" class="bean.Book">
    <!--使用property完成属性注入
        name:类里面的属性名称
        value:向属性注入的值
    -->
    <property name="name" value="时间简史"></property>
    <property name="author" value="霍金"></property>
</bean>

使用有参构造方法注入（需要生成对应有参构造方法）

<!--方式一：配置对象的创建，使用有参构造方法注入属性-->
<bean id="order" class="bean.Order">
    <constructor-arg name="name" value="时间简史"/>
    <constructor-arg name="address" value="二仙桥"/>
</bean>

<!--方式二：配置对象的创建，使用有参构造方法注入属性-->
<bean id="order" class="bean.Order">
	<constructor-arg index="0" value="时间简史"/>
	<constructor-arg index="1" value="二仙桥"/>
</bean>

p名称空间注入（简化使用set方法注入）

<!--在beans标签中添加属性xmlns:p-->
xmlns:p="http://www.springframework.org/schema/p"
<!--set方法注入属性-->
<bean id="book" class="bean.Book" p:name="时间简史" p:author="霍金"></bean>

特殊属性注入

空值与特殊符号

<bean id="book" class="bean.Book">
    <!--向属性中设置null值-->
    <property name="name">
        <null></null>
    </property>
    <!--属性值中包含特殊符号
        方式一：使用转义
        方式二：使用CDATA,<![CDATA[具体内容]]>
    -->
    <property name="author">
        <value><![CDATA[<<霍金>>]]></value>
    </property>
</bean>

bean注入（假设Employee中有Department类型属性dep）

<!--方式一-->
<bean id="dep" class="bean.Department">
    <property name="dep.name" value="行政部"></property>
</bean>
<bean id="emp" class="bean.Employee">
    <!--注入userDao对象
        name:类里属性的名称
        ref:dep属性(对象)的id值
    -->
    <property name="dep" ref="dep"></property>
</bean>

<!--方式二-->
<bean id="emp" class="bean.Employee">
    <!--设置普通属性-->
    <property name="name" value="Tom"></property>
    <!--设置对象属性-->
    <property name="dep">
        <bean id="dep" class="bean.Department">
            <property name="name" value="技术部"></property>
        </bean>
    </property>
</bean>

<!--方式三-->
<bean id="dep" class="bean.Department"></bean>
<bean id="emp" class="bean.Employee">
    <!--设置普通属性值-->
    <property name="name" value="Tom"></property>
    <!--要先在Employee类中生成dep属性的get方法！！！-->
    <property name="dep" ref="dep"></property>
    <property name="dep.name" value="行政部"></property>
</bean>

<!--方式四-->
<bean id="dep" class="bean.Department" >
    <property name="dep.name" value="行政部"></property>
</bean>
<bean id="emp" class="bean.Employee" autowire="byName"></bean>
<!--相当于在emp的bean标签中省去<property name="dep" ref="dep"></property>-->

集合属性

<!--集合类型属性注入-->
<bean id="stu" class="collection.Student">
    <!--数组类型属性注入-->
    <property name="arr">
        <array>
            <value>javaEE基础</value>
            <value>数据库</value>
        </array>
    </property>

    <!--list类型属性注入-->
    <property name="list">
        <list>
            <value>Tom</value>
            <value>Bob</value>
        </list>
    </property>

    <!--map类型属性注入-->
    <property name="map">
        <map>
            <entry key="key1" value="value1"></entry>
            <entry key="key2" value="value2"></entry>
        </map>
    </property>

    <!--set类型属性注入-->
    <property name="set">
        <set>
            <value>MySQL</value>
            <value>Redis</value>
        </set>
    </property>
</bean>

（1）在集合中设置对象类型值

<bean id="stu" class="collection.Student">
    <!--List集合类型属性注入，值为对象-->
    <property name="courseList">
        <list>
            <ref bean="course1"></ref>
            <ref bean="course2"></ref>
        </list>
    </property>
</bean>
<!--创建多个course对象-->
<bean id="course1" class="collection.Course">
    <property name="name" value="Spring5框架"></property>
</bean>
<bean id="course2" class="collection.Course">
    <property name="name" value="MyBatis框架"></property>
</bean>

（2）把集合注入部分提取出来：在Spring配置文件中引入名称空间util，使用util标签完成list集合注入提取

<!--提取list集合类型属性注入-->
<util:list id="bookList">
    <value>数据结构与算法</value>
    <value>计算机组成原理</value>
</util:list>
<!--提取list集合类型属性注入的使用-->
<bean id="book" class="collection.Bookshelf">
    <property name="bookList" ref="bookList"></property>
</bean>

IOC-注解

创建对象

<!--第一步：引入名称空间context-->
<!--第二步：开启组件扫描-->
<!--多个包用逗号隔开-->
<context:component-scan base-package="annotation.dao,annotation.service"></context:component-scan>
<!--扫描目录下所有包-->
<context:component-scan base-package="annotation"></context:component-scan>

<!--use-default-filters="false"表示现在不使用默认filter，自己配置filter
	子标签：
	context:include-filter,设置需要扫描的内容
    context:exclude-filter,设置不需要扫描的内容
		type:扫描依据
			annotation:根据注解进行扫描
-->

/**
 * 注解里面的value属性可以省略不写，默认是首字母小写的类名
 * 四个注解：@Component、@Service、@Controller、@Repository，只存在语义上的区别
 */
@Component(value = "userService")
public class UserService {
    public void add(){
        System.out.println("package service.UserService");
    }
}

注入属性

/**
 * @AutoWired，根据属性类型进行注入
 * @Qualider，根据属性名称进行注入，@Qualider和@AutoWired搭配使用
 * @Resource，可以根据类型注入，也可以根据名称注入，位于拓展包javax中
 * @Value，注入普通类型属性
 */
@Service
public class ManagerService {

    /**
     * 不需要添加set方法，只需添加注入属性注解
     * value指定要注入的值，对于@Qualifier，值指具体实现类，对@Value，值指具体值
     */
    @Autowired
    @Qualifier(value = "managerDaoImpl")
    private ManagerDao managerDao;
    
    @Value(value = "root")
	private String name;

    public void login(){
        managerDao.search();
        System.out.println("登陆成功");
    }
}

纯注解

创建配置类，替代xml配置文件，使用时改用AnnotationConfigApplicationContext()方法

@Configuration  //作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"annotation"})   //<!--开启组件扫描-->
public class SpringConfig {

}

public void test(){
        ApplicationContext context=new AnnotationConfigApplicationContext("annotation.config");
        ManagerService managerService = context.getBean("managerService", ManagerService.class);
        managerService.login();
    }

Bean的生命周期

生命周期：从对象创建到对象销毁的过程

（1）通过构造器创建bean实例（执行无参构造方法）

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

（2.5）把bean实例传递给bean的后置处理器方法

（3）调用bean的初始化方法（需要配置）

（3.5）把bean实例传递给bean的后置处理器方法

（4）使用bean

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

public class food {
    private String name;

    public food() {
        System.out.println("1.执行无参构造创建bean实例");
    }

    public void setName(String name) {
        this.name = name;
        System.out.println("2.执行set方法完成属性设置");
    }

    //初始化方法的方法名自己定，写完初始化方法后到xml中配置初始化方法
    public void init(){
        System.out.println("3.执行初始化方法");
    }

    //销毁方法的方法名自己定，写完初始化方法后到xml中配置初始化方法
    public void destroy(){
        System.out.println("5.执行销毁方法");
    }
}

<!--init-method属性配置初始化方法
    destroy-method属性配置销毁方法
-->
<bean id="food" class="lifecycle.food" init-method="init" destroy-method="destroy">
    <property name="name" value="宫保鸡丁"></property>
</bean>

public class FoodTest {
    @Test
    public void test(){
        ApplicationContext context=new ClassPathXmlApplicationContext("food.xml");
        food food = context.getBean("food", food.class);
        System.out.println("4.获取到bean对象并使用");
        System.out.println(food);

        //手动销毁bean实例
        ((ClassPathXmlApplicationContext)context).close();
    }
}

AOP-JDK

有接口的情况下使用（比如要增强UserDaoImpl中的方法，UserDaoImpl有接口UserDao，故使用JDK动态代理）

public class JDKProxy {
    public static void main(String[] args) {

        /**
         * 创建接口实现类代理对象
         * newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)
         * 返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序
         * loader：类加载器
         * interfaces：增强方法所在的类实现的接口
         * h：实现接口InvocationHandler，创建代理对象，写增强的部分
         */
        Class[] interfaces={UserDao.class};
        InvocationHandler h=new UserDaoProxy(new UserDaoImpl())
        //接口等于实现类的代理对象
        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, h);
        int add = dao.add(1, 2);
        System.out.println("结果为："+add);
    }
}

//创建代理对象代码
class UserDaoProxy implements InvocationHandler{

    //创建的是谁的代理对象，就把谁传递过来
    //有参构造传递
    private Object obj;

    public UserDaoProxy() {
    }

    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-CGLIB

基于xml

public class Book {
    public void buy(){
        System.out.println("Book中的buy");
    }
}

public class BookProxy {
    private void before(){
        System.out.println("before前置通知");
    }
}

<!--创建对象-->
<bean id="book" class="bean.Book"></bean>
<bean id="bookProxy" class="bean.BookProxy"></bean>

<!--配置aop增强-->
<aop:config>
    <!--切入点-->
    <aop:pointcut id="point" expression="execution(* bean.Book.buy(..))"/>
    <!--配置切面-->
    <aop:aspect ref="bookProxy">
        <!--用before()方法来增强指定的buy()方法-->
        <aop:before method="before" pointcut-ref="point"></aop:before>
    </aop:aspect>
</aop:config>

基于注解

@Component
public class Manager {
    public void add(){
        System.out.println("Manager中的add操作");
    }
}

<!--引入名称空间context与aop-->
<!--开启注解扫描-->
<context:component-scan base-package="bean"></context:component-scan>
<!--开启Aspectj生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

/* 创建增强类，编写增强逻辑*/
@Component
@Aspect //生成代理对象
public class ManagerProxy {
    //在增强类里面，创建方法，让不同方法代表不同通知类型

    //前置通知
    // @Before表示作为前置通知
    @Before(value = "execution(* bean.Manager.add())") //org.aspectj.lang.annotation.Before
    public void before(){
        System.out.println("before前置通知");
    }

    //后置通知（返回通知），@AfterReturning在方法返回结果之后执行，有异常时不执行
    @AfterReturning(value = "execution(* bean.Manager.add())")
    public void afterReturning(){
        System.out.println("afterReturning通知");
    }

    //异常通知
    @AfterThrowing(value = "execution(* bean.Manager.add())")
    public void afterThrowing(){
        System.out.println("afterThrowing异常通知");
    }

    //环绕通知
    @Around(value = "execution(* bean.Manager.add())")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("around环绕通知（环绕之前）");	 //	最先执行	
        proceedingJoinPoint.proceed();					// 被增强的方法执行
        System.out.println("around环绕通知（环绕之后）");	 // 紧跟被增强的方法
    }

    //最终通知，@After在方法结束后执行，无论方法是否存在异常
    @After(value = "execution(* bean.Manager.add())")
    public void after(){
        System.out.println("after后置通知");
    }
}

/**
 * 相同切入点抽取
 * 此时pointCut()就可以替代通知中value中的值execution(* bean.Manager.add())
 */
@Pointcut(value ="execution(* bean.Manager.add())")
public void pointCut(){
}

/**
 *多个增强类对同一个方法进行增强时，设置增强类的优先级，默认2147483647
 */
@Component
@Aspect
@Order(1)   //@Order(1)设置增强类的优先级，数字越小，优先级越高
public class BossProxy {
    @Before(value = "pointCut()")
    public void before(){
        System.out.println("Boss中的before前置通知");
    }
}

纯注解

@Configuration  //作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"bean"})   // 开启组件扫描
@EnableAspectAutoProxy(proxyTargetClass=true)	// 开启Aspectj生成代理对象，默认false
public class SpringConfig {

}

JdbcTemplate

Spring框架对JDBC进行封装，使用JDBCTemplate方便实现对数据库操作

相关配置

jdbc.properties配置文件

driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/spring
username=root
password=byte1024

<!--开启组件扫描-->
<context:component-scan base-package="dao"></context:component-scan>

<!--引入外部文件-->
<context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
<!--配置连接池-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${driverClassName}"></property>
    <property name="url" value="${url}"></property>
    <property name="username" value="${username}"></property>
    <property name="password" value="${password}"></property>
</bean>
<!--JdbcTemplate对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <!--注入DataSource-->
    <property name="dataSource" ref="dataSource"></property>
</bean>

public interface BookDao {
}

@Repository
public class BookDaoImpl implements BookDao{

    //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

@Service
public class BookService {
    //注入dao
    @Autowired
    private BookDao bookDao;
}

操作数据库

@Override
public void addBook(Book book) {
    String sql="insert into `book` values(?,?,?)";
    int update = jdbcTemplate.update(sql, book.getId(), book.getName());
}

@Override
public void batchAddBook(List<Object[]> lists) {
    String sql="insert into `book` values(?,?)";
    int[] ints = jdbcTemplate.batchUpdate(sql, lists);
}

@Override
public void updateBook(Book book) {
    String sql="update `book` set `name`=? where id=?";
    int update = jdbcTemplate.update(sql, book.getName(), book.getId());
}

@Override
public void batchUpdateBook(List<Object[]> lists) {
    String sql="update `book` set `name`=? where id=?";
    int[] ints = jdbcTemplate.batchUpdate(sql, lists);
}

@Override
public void deleteBook(String id) {
    String sql="delete from `book` where id=?";
    int update = jdbcTemplate.update(sql, id);
}

@Override
public void batchDeleteBook(List<Object[]> lists) {
    String sql="delete from `book` where id=?";
    int[] ints = jdbcTemplate.batchUpdate(sql, lists);
}

@Override
public int queryCount() {
    String sql="select count(*) from `book` ";
    Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
    return count;
}

@Override
public Book queryBook(String id) {
    String sql="select * from `book` where `id`=?";
    Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(Book.class), id);
    return book;
}

@Override
public List<Book> queryBooks() {
    String sql="select * from `book`";
    List<Book> books = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(Book.class));
    return books;
}

事务管理

基于注解
<!--先引入名称空间tx-->
<!--开启事务注解-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

<!--配置连接池-->
<!--JdbcTemplate对象-->
<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="dataSource"></property>
</bean>

在service类上面（或service类里面的方法上面）添加事务注解@Transactional。添加到类上相当于给类中所有方法添加了事务注解，添加到方法上面只是给特定方法添加事务注解

// @Transactional参数配置
/**
 * propagation：事务传播行为
 * 多事务方法直接进行调用，这个过程事务是如何进行管理的
 * 事务方法：对数据库表数据进行变化的操作（增删改）
 */
@Transactional(propagation = Propagation.REQUIRED)

/*isolation：事务隔离级别*/
@Transactional(isolation = Isolation.REPEATABLE_READ)

/**
 * timeout：超过时间
 * 事务需要在一定时间内进行提交，如果不提交，会进行回滚
 * 默认值为-1，设置时间以秒为单位
 */

/**
 * readOnly：是否只读
 * 读：查询操作，写：增删改操作
 * 默认值为false，表示可读可写，当设置true时，只能读
 */

/**
 * rollbackFor：回滚
 * 设置出现哪些异常进行事务回滚
 */

/**
 * noRollbackFor：不回滚
 * 设置出现哪些异常不进行事务回滚
*/
事务的传播行为说明
REQUIRED如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。这是默认值
REQUIRES_NEW创建一个新的事务，如果当前存在事务，则把当前事务挂起
SUPPORTS如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行
NOT_SUPPORTED以非事务方式运行，如果当前存在事务，则把当前事务挂起
NEVER以非事务方式运行，如果当前存在事务，则抛出异常
MANDATORY如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常
NESTED如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于REQUIRED
基于xml
<!--先引入名称空间tx-->
<!--开启事务注解-->
<tx:annotation-driven transaction-manager="transactionManager"></tx:annotation-driven>

<!--配置连接池-->
<!--JdbcTemplate对象-->
<!--创建事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--注入数据源-->
    <property name="dataSource" ref="dataSource"></property>
</bean>

<!--配置通知-->
<tx:advice id="advice">
    <!--配置事务参数-->
    <tx:attributes>
        <!--指定哪种规则的方法上面添加事务
			name:方法名字，可正则
		-->
        <tx:method name="transferAccount" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>
<!--配置切入点和切面-->
<aop:config>
    <!--配置切入点-->
    <aop:pointcut id="point" expression="execution(* service.UserService.*(..))"/>
    <!--配置切面(将事务和方法相关联)-->
    <aop:advisor advice-ref="advice" pointcut-ref="point"></aop:advisor>
</aop:config>
纯注解
@Configuration  //配置类
@ComponentScan(basePackages = {"service","dao"} )   //开启组件扫描
@EnableTransactionManagement    //开启事务
public class TxConfig {

    //创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();

        druidDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        druidDataSource.setUrl("jdbc:mysql://localhost:3306/spring5");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("byte1024");

        return druidDataSource;
    }

    //创建JdbcTemplate对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource){
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //到IOC容器中根据类型找到dataSource
        //注入dataSource
        jdbcTemplate.setDataSource(dataSource);

        return jdbcTemplate;
    }

    //创建事务管理
    @Bean
    public DataSourceTransactionManager getDataSourceTransactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager=new DataSourceTransactionManager(dataSource);
        return transactionManager;
    }

}

个人博客：字节幺零二四
gzh：字节幺零二四

字节幺零二四
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring5学习之基础知识总结
p1830095583的博客
05-30 427
1.概述 1、Spring 是轻量级的开源的 JavaEE 框架 2、 Spring 可以解决企业应用开发的复杂性 3、Spring 有两个核心部分：IOC 和 Aop IOC：控制反转，把创建对象过程交给 Spring 进行管理Aop：面向切面，不修改源代码进行功能增强 4、Spring 特点 方便解耦，简化开发Aop 编程支持方便程序测试方便和其他框架进行整合方便进行事务操作降低 API 开发难度 2.入门Demo 1.jar包引入 <project xmlns="http://maven
spring知识点梳理
07-25
spring从搭建配置到简单开发的一个整体流程,比较适合打基础的朋友!
Spring5框架相关知识点整理
HardyZhan的博客
04-08 937
Spring5框架 IOC容器 控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理。 使用IOC目的:降低耦合度 IOC底层原理 xml解析 工厂模式 反射 IOC接口(BeanFactory) Spring提供IOC容器实现两种方式: BeanFactory:IOC容器基本实现方式，是Spring内部的使用接口，一般不提供给开发人员使用。 注意:此方式在加载配置文件时不会创建对象，在获取对象(使用)时才会去创建对象。 ApplicationContext:BeanFactory
Spring5基本知识
qq_33813721的博客
12-01 479
本篇论述的内容 spring历史； spring Ioc; spring自动装配； spring aop； spring 事务 注：本文内容来自b站狂神说java spring框架学习的笔记 一、spring简介 二、spring Ioc 三、spring自动装配 三、spring aop 3.1、静态/动态代理 ...
spring5框架知识点总结（一）IOC篇
m0_50654102的博客
03-27 286
spring5框架知识点总结 Spring5 框架概述 1、Spring 是轻量级的开源的 JavaEE 框架 2、Spring 可以解决企业应用开发的复杂性 3、Spring 有两个核心部分：IOC 和 Aop （1）IOC：控制反转，把创建对象过程交给 Spring 进行管理 （2）Aop：面向切面，不修改源代码进行功能增强 4、Spring 特点 （1）方便解耦，简化开发 （2）Aop 编程支持 （3）方便程序测试 （4）方便和其他框架进行整合 （5）方便进行事务操作 （6）降低 API 开发难度 I
Spring5「知识点整理」中......
10-04 191
Spring5-知识点整理欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使...
Spring相关知识点的总结与梳理
08-26
Spring框架是Java开发中不可或缺的一部分，它...通过上述知识点，我们可以看到Spring如何帮助开发者更有效地设计和管理应用，降低复杂性，提高可维护性和可测试性。理解并熟练掌握这些概念是成为Spring专家的关键步骤。
Spring核心知识点完整梳理（史上最全，值得收藏）
03-18
这份名为“Spring核心知识点完整梳理（史上最全，值得收藏）”的资料可能是对Spring框架进行全面剖析的文档，涵盖了Spring的各种关键概念和技术。 1. **依赖注入（Dependency Injection，DI）**：这是Spring的核心...
Spring核心知识点
最新发布
04-06
Spring核心知识点
Spring框架知识点
08-07
SSM框架
Spring5知识点综合笔记
SIESTA030的博客
04-14 247
目录：1.初次使用spring5：maven配置如下第一步：创建名为applicationContext的资源文件，将资源文件的框架导入：第二步，开始写读取xml文件的核心代码：第三步，利用junit测试：番外：如何配置有参构造函数？总结：2、spring的配置2.1 别名（alias了解）2.2 Bean的配置（掌握）2.3 导入（import）3、依赖注入3.1 构造器注入3.2 Set方式注入==（重点）==4、Bean的作用域4.1 单例模式（spring的默认机制，单线程一般使用这个模式）4.2
Spring5的知识总结
qq_53502890的博客
09-10 143
一.概念 spring是一个最完善的轻量级javaEE企业级开发框架。 Ioc 在javase阶段，我们创建要想在一个对象中引入其他对象，需要通过new对象的方式去创建，这种方式会造成代码耦合性高，spring中的Ioc在对象初始化时不等对象请求就将对象传递给它，这里的底层原理运用到工厂模式和反射技术。 1.xml的方式获取 《bean》标签配置 这里spring中有两个接口，实现了加载xml文件，通过反射获...
Spring5-基础知识
发型决定高度的博客
11-11 461
Spring 1. Spring的基本概述 spring是一个轻量级的JAVAEE的开源框架 spring可以解决企业级应用开发的复杂性 spring有两个核心部分IOC和AOP： IOC：控制反转，把创建对象的过程交给spring进行管理 AOP：面向切面，在不修改源代码的情况下进行功能的增强 spring的特点： 方便解藕，简化开发 Aop编程的支持 方便测试的集成 方便和其他的框架进行整合 方便进行事务的操作和降低api的使用难度
Spring5知识点总结（二、AOP）
weixin_43369516的博客
11-15 434
1.代理模式 动态代理和静态代理 角色一样 动态代理类是动态生成的，不是我们直接写好的！ 动态代理：基于接口，基于类 基于接口：JDK的动态代理【使用】 基于类：cglib java字节码 静态代理 动态代理 //这个类，自动生成代理类 public class ProxyInvocation implements InvocationHandler { //被代理的接口 private Rent rent; public void setRent(Rent re
1.Spring5基础知识
weixin_43864861的博客
06-24 141
本篇文章是根据B站狂神说Java系列的Spring5的笔记记录 —— 第一篇Spring5入门了解 gitee：https://gitee.com/ywq869819435/spring5 1、Spring 1.1、简介 2002首次推出了Spirng的雏形：interface21 2004.3月发布spring 1.0 理念：使现有的技术更加容易使用，本身就是一个大杂烩，整合了现有的技术框架！ SSH： Struct2 + Spring + Hibernate SSM：SpringMvc + Sprin
spring5框架知识点总结（二）IOC篇
m0_50654102的博客
03-31 96
本文接上一篇文章：spring5框架知识点总结（一） 文章目录spring5框架知识点总结（二）IOC 操作 Bean 管理（xml 注入集合属性）IOC 操作 Bean 管理（FactoryBean）IOC 操作 Bean 管理（bean 作用域）IOC 操作 Bean 管理（bean 生命周期） spring5框架知识点总结（二） IOC 操作 Bean 管理（xml 注入集合属性） 1、注入数组类型属性 2、注入 List 集合类型属性 3、注入 Map 集合类型属性 （1）创建类，定义数组、list
Spring5知识点总结——事务
weixin_43369516的博客
11-15 367
1.声明式事务 事务的acid原则： 原子性 一致性 隔离性 多个业务可能操作一个资源，防止数据损坏 持久性 事务一旦提交，无论系统发生什么问题，结果都不会被影响。 Spring中的事务管理 声明式事务：AOP 编程式事务：代码管理事务 spring事务的七种事务属性： PROPAGATION_REQUIRED – 支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 PROPAGATION_SUPPORTS – 支持当前事务，如果当前没有事务，就以非事务方式执行 PROPAGATI
2021年最详细的Spring5知识点
远赴人间惊鸿宴,一睹人间盛世颜！
05-25 263
IOC(接口) 1.IOC思想基于IOC容器完成，IOC容器底层就是对象工厂。 2.Spring提供IOC容器实现的两种方式：（两个接口） （1）BeanFactory:IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用。 特点：加载配置文件的时候不会创建对象，在获取对象（使用）才去创建对象。 （2）ApplicationContext:BeanFactory接口的子接口，提供更多更强大的功能，一般是由开发人员进行使用。 特点：加载配置文件时就会把配置文件对象进行创建。
Spring实战（第5版）核心知识点总结
weixin_42101628的博客
03-14 1841
Spring实战（第5版）1. Spring基础1.1 Spring起步1.2 开发Web应用1.3 使用数据1.4 保护Spring1.5 使用配置属性2. Spring集成3. 反应式Spring4. 云原生Spring5. 部署Spring 1. Spring基础 1.1 Spring起步 Spring的核心是提供一个容器（container），又叫spring Application Context，会创建和管理bean，将bean装配在一起基于依赖注入（DI），依赖容器去创建和维护所有的组件，注入
08课 Spring5讲义（2018.8.5）.docx
11-24
本文将重点介绍Spring框架的核心知识点，并深入探讨每个知识点的原理和实现方式。 首先，我们将介绍IoC（控制反转）的原理分析。IoC是Spring框架的核心概念之一，它通过将对象之间的依赖关系交给容器管理，实现了...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值