spring

最新推荐文章于 2024-11-06 09:23:18 发布

马马可心

最新推荐文章于 2024-11-06 09:23:18 发布

阅读量150

点赞数

文章标签： spring java idea

本文链接：https://blog.csdn.net/weixin_58993861/article/details/124590827

版权

本文深入探讨Spring框架，从IOC控制反转的原理和实现方式，包括无参和有参构造器的创建，到配置别名、Bean注入、依赖注入的多种方式。接着介绍了Spring注解开发，如@Component、@Repository、@Service和@Controller，并讨论了XML与注解的结合使用。进一步讲解了使用JavaConfig实现Bean配置，并分析了代理模式的优缺点。最后，简要提到了Spring AOP的应用和Spring与Mybatis的集成。

摘要由CSDN通过智能技术生成

1.ioc 控制反转

mapper层一个接口有多个实现类
我们业务层如果需要调用 mapper的实现
必须在业务层把需要的实现new一遍这样很繁琐

如果使用set方法的话业务层则不需要修改 controller直接调用

在项目中我们肯定遇到过加个注解就可以调用该对象，该对象我们并没有创建，其实是spring（的ioc）帮我们创建了，这就叫做控制反转。
写个类配置个bean就能直接使用了。

控制：谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用spring后，对象是有Spring来创建的。

反转：程序本身不创建对象，而变成被动的接受对象。

IOC：对象由Spring 创建管理装配

ioc的创建方式：

1.使用无参构造创建对象，默认！
2.假设我们要使用有参构造创建对象。

<!--第一种方式：下标赋值    -->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg index="0" value="狂神说Java"/>
</bean>

<!--第二种方式：通过类型的创建，不建议使用    -->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg type="java.lang.String" value="lifa"/>
</bean>

<!--第三种方式：直接通过参数名来设置    -->
<bean id="user" class="com.kuang.pojo.User">
    <constructor-arg name="name" value="李发"/>
</bean>

2.spring配置

别名：

    <!--别名，如果添加了别名，我们也可以使用别名获取到这个对象-->
    <alias name="user" alias="userNew"/>

Bean的配置

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

般用于团队开发使用，它可以将多个配置文件，导入合并为一个。
假设，现在项目中有多个人开发，这三个人负责不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的！

<import resource="bean.xml"/>
<import resource="bean2.xml"/>
<import resource="bean3.xml"/>

3.依赖注入

构造器注入（有参，无参）

set注入【重点】

public class Student {

    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbies;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private Properties info;
    set get 有参 无参
}

    <bean id="address" class="com.kuang.pojo.Address">
        <property name="address" value="西安"/>
    </bean>

    <bean id="student" class="com.kuang.pojo.Student">
        <!--第一种：普通值注入，value        -->
        <property name="name" value="黑心白莲"/>

        <!--第二种：        -->
        <property name="address" ref="address"/>

        <!--数组        -->
        <property name="books">
            <array>
                <value>红楼梦</value>
                <value>西游记</value>
                <value>水浒传</value>
                <value>三国演义</value>
            </array>
        </property>

        <!--List        -->
        <property name="hobbies">
            <list>
                <value>打篮球</value>
                <value>看电影</value>
                <value>敲代码</value>
            </list>
        </property>

        <!--Map        -->
        <property name="card">
            <map>
                <entry key="身份证" value="123456789987456321"/>
                <entry key="银行卡" value="359419496419481649"/>
            </map>
        </property>

        <!--Set        -->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>COC</value>
                <value>BOB</value>
            </set>
        </property>

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

        <!--Properties        -->
        <property name="info">
            <props>
                <prop key="driver">20191029</prop>
                <prop key="url">102.0913.524.4585</prop>
                <prop key="user">黑心白莲</prop>
                <prop key="password">123456</prop>
            </props>
        </property>

    </bean>

扩展方式注入

<?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:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--p命名空间注入，可以直接注入属性的值：property-->
    <bean id="user" class="com.kuang.pojo.User" p:name="黑心白莲" p:age="20"/>

    <!--c命名空间注入，通过构造器注入：constructor-args-->
    <bean id="user2" class="com.kuang.pojo.User" c:name="狂神" c:age="22"/>

</beans>

    @Test
    public void test2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");

        User user = context.getBean("user",User.class);
        System.out.println(user);

        User user2 = context.getBean("user2",User.class);
        System.out.println(user2);
    }

注意点：p命名和c命名空间不能直接使用，需要导入xml约束！

 xmlns:p="http://www.springframework.org/schema/p"
 xmlns:c="http://www.springframework.org/schema/c"

4.spring注解开发（Bean注入）

@Component 组件等价于

dao [@Repository]

service [@Service]

controller [@Controller]

这四个spring注解都是一样的，都是讲莫格类注入到spring容器中，装配Bean

@Value

相当于

如果使用注解开发我们需要应用上下文配置类，扫描指定的包，使注解生效

XMl与注解：

xml更加万能，适用于任何场合！维护简单方便。

注解不是自己的类使用不了，维护相对复杂!

xml与注解的最佳实践：

xml用来管理bean

注解只负责属性的注入

5.使用javaconfig实现Bean配置（装配）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O4mXgHDW-1651737544744)(C:\Users\john\AppData\Roaming\Typora\typora-user-images\image-20220504175313254.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Net3qub8-1651737544745)(C:\Users\john\AppData\Roaming\Typora\typora-user-images\image-20220504175554801.png)]

@config 代表是一个配置类，相当于应用上下文xml配置中的 bean

@CompontScan 包扫描相当于 Bean中的 class=“com.derking.pojo”

@Import Bean导入把bean倒入到一个 xml 里

//注册一个Bean 相当于我们之前写的一个Bean标签
//这歌方法的名字，就相当于bean标签中id属性
//这歌方法的返回值，就相当于bean标签中的class属性
@Bean
public User user(){
    return new User();
}

6.代理模式

静态代理

在这里插入图片描述

角色分析：

抽象角色：一般会使用接口或者抽象类来解决
真实角色：被代理的角色
代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
客户：访问代理对象的人！

代理模式的好处：

可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
公共角色就交给代理角色！实现了业务的分工！
公共业务发生扩展的时候，方便集中管理！

缺点：

一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率会变低~

7.Spring实现AOP

【重点】使用AOP织入，需要导入一个依赖包！

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

方式一： 使用Spring的API接口【主要是SpringAPI接口实现】

1.在service包下，定义UserService业务接口和UserServiceImpl实现类

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();
}

public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("增加了一个用户！");
    }

    public void delete() {
        System.out.println("删除了一个用户！");
    }

    public void update() {
        System.out.println("更新了一个用户！");
    }

    public void select() {
        System.out.println("查询了一个用户！");
    }
}

2.我们需要横贴的第一步，这里横贴日志，一个Log前置增强和一个AfterLog后置增强类

public class Log implements MethodBeforeAdvice {

    //method: 要执行的目标对象的方法
    //args：参数
    //target：目标对象
    public void before(Method method, Object[] agrs, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");
    }
}

public class AfterLog implements AfterReturningAdvice {

    //returnValue： 返回值
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了"+method.getName()+"方法，返回结果为："+returnValue);
    }
}

3.最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束，配置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"
       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-->
    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
    <bean id="log" class="com.kuang.log.Log"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>

    <!--方式一：使用原生Spring API接口-->
    <!--配置aop:需要导入aop的约束-->
    <aop:config>
        <!--切入点：expression：表达式，execution(要执行的位置！* * * * *)-->
        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>

        <!--执行环绕增加！-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>

</beans>

4.测试

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        //动态代理代理的是接口：注意点
        UserService userService = (UserService) context.getBean("userService");

        userService.add();
//        userService.select();
    }
}

7.Spring-mybatis

1.导入依赖静态过滤

<?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">
    <parent>
        <artifactId>spring5</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-mybatis</artifactId>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.0.RELEASE</version>
        </dependency>
        <!--Spring操作数据库的话，还需要一个spring-jdbc
               -->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.13</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.2</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
        </dependency>
    </dependencies>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>


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

</project>

2.配置applicationContext.xml

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


2.配置applicationContext.xml

~~~ xml

~~~

马马可心

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫