关于spring:面试突击spring看这一篇就够了给你总结的清新脱俗

3次阅读

共计 12810 个字符，预计需要花费 33 分钟才能阅读完成。

Rod Johnson，Spring Framework 创始人，驰名作者。很难设想 Rod Johnson 的学历，真的让好多人大吃一惊，他是悉尼大学的博士，然而他的业余不是计算机，而是音乐学。
Spring 理念：使现有的技术更加容易应用，自身是一个大杂烩，整合了现有的技术框架！
SSH：Struct2 + Spring + Hibernate!
SSM：SpringMVC + Spring + Mybatis!
依赖导入：

 <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.5</version>
    </dependency>

总结：Spring 就是一个轻量级的管制反转（IOC）和面向切面编程（AOP）的框架

毛病：“配置繁琐，配置天堂”所以 SpringBoot 就进去了
IOC：以前程序主动权在程序员手中，用户需要得通过程序员批改，IOC 就是扭转这种伎俩，将控制权交到用户手中：管制反转。大大解除了程序的耦合性，这样程序员就能够更加专一于业务层开发

@Data
public class Student {
    private String name;
    private int id;

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--    实体类映射 -->
<!--    默认应用无参构造函数创建对象，-->
<!--    若要应用有参，须要用 <constructor-arg-->
    <bean id="student" class="com.song.pojo.Student">
        <constructor-arg name="name" value="mike"/>
        <constructor-arg name="id" value="2"/>
        <property name="name" value="hehe"/>
    </bean>

<!--    <bean id="..." class="...">-->

</beans>

public class myTest {
    @Test
    public void test(){ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) applicationContext.getBean("student");
        System.out.println(student.toString());
    }
}

思考：对象是如何创立的？
Spring 主动创建对象，由 Spring 容器给对象属性赋值
这个过程就称为管制反转
管制：谁来管制对象的创立，传统应用程序的对象是由程序自身管制创立的，应用 Spring 后，对象是由 Spring 来创立的。
反转：程序自身不创建对象，变成被动的承受 Spring 容器创立的对象
容器通过 set 办法进行属性值的注入
对象由 Spring 来创立，治理，拆卸！

<!--
   id：bean 的惟一标识符，也就是相当于咱们学的对象名
   class：bean 对象所对应的全限定名：包名 + 类名
   name：也是别名，而且 name 能够同时取多个别名
       -->
   <bean id="userT" class="com.kuang.pojo.UserT" name="user2 u2,u3;u4">
       <property name="name" value="吴亦凡"/>
   </bean>
   <import resource=baen.xml/>

当实体类呈现简单属性时如下：

@Data
public class Person {
    private String name;// 名字
    private Cat cat;// 宠物
    private String[] books;// 书籍
    private List<String> hobbies;// 喜好
    private Map<String,String> card;// 卡
    private Set<String> games;// 游戏
    private String wife;// 妻子
    private Properties info;// 配置信息
    private Dog dog;
}

<!--        援用 ref-->
        <property name="cat" ref="cat"/>
        <bean id="cat" class="com.pojo.Cat"/>

<!--        数组 arry-->
        <property name="books">
            <array>
                <value>java 核心技术 </value>
                <value>jvm 入门 </value>
                <value> 数据库入门到入土 </value>
                <value> 西游记 </value>
            </array>
        </property>

<!--        list 汇合 List-->
        <property name="hobbies">
            <list>
                <value> 唱 </value>
                <value> 跳 </value>
                <value>rap</value>
            </list>
        </property>

set 时换一下关键字即可

<!--        Map 汇合 map-->
        <property name="card">
            <map>
                <entry key="身份证" value="5206565656565"/>
                <entry key="银行卡" value="111111111111111"/>
            </map>
        </property>

<!--        null-->
        <property name="wife">
            <null/>
        </property>

<property name="info">
           <props>
               <prop key="url">https//www.baidu.com</prop>
               <prop key="driver">https//www.baidu.com</prop>
           </props>
       </property>

原因：当一个实体类中有其余类的援用属性时咱们通常在 xml 中采纳 ref 的形式指向另一个 Bean，这种形式很繁琐，如下：

 <bean id="student" class="com.song.Student">
        <property name="name" value="mike"/>
        <property name="sex" value="男"/>
        <property name="dog" ref="dog"/>
        <property name="cat" ref="cat"/>
    </bean>
    <bean id="dog" class="com.song.Dog"/>
    <bean id="cat" class="com.song.Cat"/>

而主动拆卸有次要两种形式：xml 中 autowire 主动拆卸和注解主动拆卸

xml
在 bean 标签中退出 autowire 标签即可

小结：

ByName 的时候，须要保障所有 bean 的 id 惟一，并且这个 bean 须要和主动注入的属性的 set 办法的值统一！
ByType 的时候，须要保障所有 bean 的 class 惟一，并且这个 bean 须要和主动注入的属性的类型统一！

应用注解实现主动拆卸
特地简略导入注解束缚——》配置注解的反对——》应用 @Autowire 注解
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"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd"
>

应用注解

   @Value("吴亦凡")
    private String name;
    private String sex;
    @Autowired
    private Dog dog;
    @Autowired
    private Cat cat;

应用 @Resource(java 内置)，用法和下面一样，

区别：@Autowired 优先 byType,@Resource 优先 byName 而后 byType

1、导入 AOP 包和束缚
aop 包在导入 Springwebmvc 时候就一起导入进来了

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd"
>
    // 扫描包下的注解
    <context:component-scan base-package="com.song"/>
    <context:annotation-config/>
</beans>

Aop:Aspect Oriented Programming 的缩写, 意思是面向切面编程，动静的在程序运行期间找个切点将一段程序执行插入进去，实现了在不改变源程序的根底下减少性能；
长处：有了 AOP，咱们能够定义穿插的关系，并将这些关系利用于跨模块的、彼此不同的对象模型。AOP 同时还能够让咱们层次化功能性而不是嵌入功能性，从而使得代码有更好的可读性和易于保护。它会和面向对象编程单干得很好。

Spring 中的 Aop：

接口办法：

1、导入 aspectjweaver 依赖

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>

2、编写接口和实现类

public interface BookDao {
    // 增删查改
    public void addBook();
    public void deleteBook();
    public void selectBook();
    public void updateBook();}

public class BookDaoImpl implements BookDao {public void addBook() {System.out.println("减少了一本书");
    }

    public void deleteBook() {System.out.println("删除了一本书");
    }

    public void selectBook() {System.out.println("查找了一本书");
    }

    public void updateBook() {System.out.println("更新了一本书");
    }
}

要向切口插入的性能

public class Log implements MethodBeforeAdvice {
    //method: 要执行的指标对象的办法
    //args：参数
    //target：指标对象
    public void before(Method method, Object[] objects, Object o) throws Throwable {System.out.println(o.getClass().getName()+"的"+method.getName()+"办法执行了");
    }
}

3、编写 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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://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="bookDaoImpl" class="com.song.service.BookDaoImpl">

    </bean>
    <bean id="log" class="com.song.log.Log"/>
<!--    配置 aop-->
    <aop:config>
<!--        切入点 -->
        <aop:pointcut id="pointcut" expression="execution(* com.song.service.BookDaoImpl.*(..))"/>
<!-- 要切入的办法 -->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

4、测试：

    public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
           // 代理类代理的是一个接口而不是实现类
        BookDao bookDaoImpl = (BookDao) context.getBean("bookDaoImpl");
        bookDaoImpl.addBook();}

后果：

1、自定义告诉类

// 自定义告诉办法
public class Aspect {public void before(){System.out.println("办法执行前");
    }
    public void after(){System.out.println("办法执行后");
    }
}

2、xml

<aop:config>
    <aop:aspect ref="aspect">
        <aop:pointcut id="point" expression="execution(* com.song.service.BookDaoImpl.*(..))"/>
<!--        要实现的告诉办法 -->
        <aop:before method="before" pointcut-ref="point"/>
        <aop:after method="after" pointcut-ref="point"/>
    </aop:aspect>
</aop:config>

3、测试

很简略；标记切面类–》标记告诉–》配置 xml 开启注解反对

@Aspect
public class AspectAnoation {@Before("execution(* com.song.service.BookDaoImpl.*(..))")
    public void before(){System.out.println("办法执行前");
    }
    @After("execution(* com.song.service.BookDaoImpl.*(..))")
    public void after(){System.out.println("办法执行后");
    }
}

    <bean id="AspectAnoation" class="com.song.diy.AspectAnoation"/>
<!--    开起注解反对 -->
    <aop:aspectj-autoproxy/>

总配置文件——> 编写实体类——> 编写接口——> 编写接口对应 xml 文件——> 测试
1、导入所有依赖：
junit
mybatis
mysql 数据库
spring 相干
aop 织入器
mybatis-spring 整合包【重点】在此还导入了 lombok 包。
配置 Maven 动态资源过滤问题！

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.24</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.5</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>


    </dependencies>
    <build>
        <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
        </resources>
    </build>
</project>

2、实体类

@Data
public class User {
    private int userId;
    private String userName;
    private String password;
    private String sex;
    private String email;
}

3、接口及对应的配置文件

public interface UserMapper {List<User> getUser();
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.song.mapper.UserMapper">
    <select id="getUser" resultType="com.song.pojo.User">
    select * from users
  </select>
</mapper>

4、mybatisconfig 配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/testweb?userSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/song/mapper/UserMapper.xml"/>
    </mappers>
</configuration>

5、工具包：

public class MybatisUtil {
    //sqlSessionFactory --> sqlSession

        static SqlSessionFactory sqlSessionFactory = null;

        static {
            try {
                // 应用 Mybatis 第一步：获取 sqlSessionFactory 对象
                String resource = "mybatisConfig.xml";
                InputStream inputStream = Resources.getResourceAsStream(resource);
                sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
            } catch (IOException e) {e.printStackTrace();
            }
        }

        // 既然有了 SqlSessionFactory，顾名思义，咱们能够从中取得 SqlSession 的实例.
        // SqlSession 提供了在数据库执行 SQL 命令所需的所有办法。public static SqlSession getSqlSession(){return sqlSessionFactory.openSession();
        }
    }

6、测试：

   @Test
    public void test(){SqlSession sqlSession = MybatisUtil.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.getUser();}

鸟瞰图：Spring-Mybatis

以下为过程对应代码

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
">
<!--    2、数据源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="username" value="root"/>
        <property name="url" value="jdbc:mysql://localhost:3306/testweb?userSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=UTC"/>
        <property name="password" value="123456"/>
    </bean>
<!--    3、SqlSessionFactoryBean 工程 -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:mybatisConfig.xml"/>
        <property name="mapperLocations" value="classpath:com/song/mapper/*.xml"/>
    </bean>
<!--    4、注入 -->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
<!--    6、注册 bean-->
    <bean id="userMapper" class="com.song.mapper.UserMapperImpl">
        <property name="sqlSessionTemplate" ref="sqlSession"/>
    </bean>
</beans>

实现类：

// 创立实现类配合 bean
public class UserMapperImpl implements UserMapper {
    //sqlsession
    private SqlSessionTemplate sqlSessionTemplate;
    //set 办法用来注入
    public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {this.sqlSessionTemplate = sqlSessionTemplate;}

和形式二前四步一样，第五步不再创立公有办法而是继承一个类，调用类办法失去 sqlSession，情理还是一样
实现类：

public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {public List<User> getUser() {return getSqlSession().getMapper(UserMapper.class).getUser();}
}

bean:

    <bean id="userMapper2" class="com.song.mapper.UserMapperImpl2">
        <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>

在文章的最初作者为大家整顿了很多材料！包含 java 外围知识点 + 全套架构师学习材料和视频 + 一线大厂面试宝典 + 面试简历模板 + 阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题 +Spring 源码合集 +Java 架构实战电子书等等！

欢送关注公众号：前程有光，支付！

正文完

spring

发表至： spring

2021-04-28

0

关于spring:编程体系结构08SpringMvcBoot框架

关于spring:77道Spring面试题及答案整理2021最新版

关于spring:springboot2之优雅处理返回值

关于spring:详解Spring中Bean的作用域与生命周期

关于c++:大数相关大数相加相除比较

关于spring:面试突击spring看这一篇就够了给你总结的清新脱俗

Spring 及 IOC 介绍

Spring 简介

IOC 创立及重点配置

新建 Maven 我的项目，导入依赖，编写实体类

编写 xml 文件

测试

Spring 重点配置！

依赖注入以及主动装 Bean

援用注入 cat

数组 books

list、set 汇合 hobbies games

map 汇合 card

null wife

properties info

主动拆卸 Bean

应用注解开发（improtant）

AOP

第一种形式：spring 中 Api 接口实现 AOP：

第二种形式：自定义切面类

第三种形式：注解形式！

整合 Mybatis

mybatis 简略温习

整合形式一

整合形式三：

最初

站内搜索