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

83次阅读

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

Spring 及 IOC 介绍

Spring 简介

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 就是扭转这种伎俩，将控制权交到用户手中：管制反转。大大解除了程序的耦合性，这样程序员就能够更加专一于业务层开发

IOC 创立及重点配置

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

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

编写 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
        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 来创立，治理，拆卸！

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

依赖注入以及主动装 Bean

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

@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;
}

援用注入 cat

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

数组 books

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

list、set 汇合 hobbies games

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

set 时换一下关键字即可

map 汇合 card

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

null wife

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

properties info

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

主动拆卸 Bean

原因：当一个实体类中有其余类的援用属性时咱们通常在 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

应用注解开发（improtant）

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

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

Spring 中的 Aop：

第一种形式：spring 中 Api 接口实现 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/>

整合 Mybatis

mybatis 简略温习

总配置文件——> 编写实体类——> 编写接口——> 编写接口对应 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:5分钟GET我使用Github-5-年总结的这些骚操作
SpringCloud-第一篇-初见
关于spring:SpringBoot-Mybatis系列之插件机制-Interceptor
听说你还没学Spring就被源码编译劝退了30张图带你玩转Spring编译