初识 Spring

最新推荐文章于 2024-09-27 20:07:43 发布

赞zz

最新推荐文章于 2024-09-27 20:07:43 发布

阅读量46

点赞数 1

文章标签： spring java mysql

本文链接：https://blog.csdn.net/m0_69157514/article/details/132407065

版权

一、什么是Spring框架

是一个轻量级的企业级应用框架
企业应用开发的"一站式"选择，贯穿于表现层、业务层、持久层

二、Spring框架的优点

低侵入式设计
独立于各种应用服务器
依赖注入特性将组件关系透明化，降低耦合度
面向切面编程特性允许将通用任务进行集中式处理
与第三方框架的良好整合

三、Spring体系结构

四、Spring设计理念

是面向Bean的编程

五、Spring两大核心技术

控制反转(IoC：Inversion of Control) / 依赖注入(DI：Dependency Injection)
面向切面编程(AOP：Aspect Oriented Programming)

六、什么是控制反转和依赖注入

控制反转(IOC)：创建对象的控制权转移，是一种程序设计思想

依赖注入(DI)：将依赖的对象注入到需要的类中去，是“控制反转”设计思想的具体实现方式

七、如何使用控制反转和依赖注入

可以通过四种实现方法：①get,set注入 ②构造函数注入 ③注解 ④p命名空间注入

①get,set注入

<bean id="users" class="domain.Users">
        <property name="id" value="1001"></property>
        <property name="name" value="星星"></property>
</bean>
 
public void textUsers(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        Users users= (Users) context.getBean("users");
        System.out.println(users.toString());
 }

②构造函数注入

Mapper中的：
public interface SmsUserMapper {
    /**
     * 新增注入
     * @return
     */
    int insert();
}
 
public class SmsUserMapperImpl implements SmsUserMapper {
    /**
     * 新增注入
     *
     * @return
     */
    @Override
    public int insert() {
        System.out.println("执行了新增方法......");
        return 0;
    }
}
 
Service中的：
public interface UserService {
    /**
     * 新增注入
     * @return
     */
    int insert();
}
 
public class UserServiceImpl implements UserService{
    public SmsUserMapper smsUserMapper;
    public UserServiceImpl(SmsUserMapper smsUserMapper) {
        this.smsUserMapper = smsUserMapper;
    }
 
    /**
     * 新增注入
     *
     * @return
     */
    @Override
    public int insert() {
        System.out.println("执行了新增方法......");
        return 0;
    }
}
 
<!--构造注入-->
    <bean id="userMapper" class="mapper.SmsUserMapperImpl"></bean>
    <bean id="userService" class="service.UserServiceImpl">
        <constructor-arg ref="userMapper"></constructor-arg>
    </bean>
 
测试类：
public void testService(){
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService=(UserService) context.getBean("userService");
        userService.insert();
    }

③注解

1.先在Mapper实现类中加上注解，这个注解相当于<bean id="userMapper" class="mapper.SmsUserMapperImpl"></bean>

Spring提供了多个注解，用于实现依赖注入、控制反转和其他常见的功能。以下是一些常用的Spring注解：

@Component：用于将类标记为组件，表示该类是一个由Spring管理的组件。可以与@Autowired一起使用，实现依赖注入。
@Controller：用于标记控制器类，处理请求并返回响应。
@Service：用于标记服务类，表示该类提供业务逻辑的服务。
@Repository：用于标记数据访问层（DAO）类，表示该类用于访问数据库或其他持久化机制。

④p命名空间注入

1.先添加p命名空间的声明：xmlns:p="http://www.springframework.org/schema/p"

<bean id="users" class="domain.Users" p:name="张三" p:id="23"></bean>

八、编写第一个Spring程序

1.先导入jar包的坐标

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>

2.写一个HelloSpring类

public class HelloSpring {
    //定义hello属性，该属性的值将通过Spring框架进行设置
    private String hello=null;
 
    /**
     * 输出方法，从Spring配置文件中获取属性并输出
     */
    public void print(){
        System.out.println("Spring say:,"+this.getHello()+"!");
    }
    public String getHello(){
            return hello;
    }
    public void setHello(String hello){
        this.hello=hello;
    }
}

3.编写Spring配置文件

新建好后这就是配置文件中的关键配置信息

然后我们开始在配置文件中开始写

    <bean id="helloSpring" class="domain.HelloSpring">
        <!--property元素用来为实例的属性赋值，此处调用setHello()方法实现赋值操作-->
        <property name="hello">
            <!--此处将字符串赋值给hello属性-->
            <value>反转的人生，如此惊艳</value>
        </property>
    </bean>

写好后我们就可以编写测试类了

面向切面编程(AOP)

1.简介

AOP

AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合式降低，提高程序的可重用性，同时提高了开发的效率。

AOP原理

将复杂的需求分解出不同方面，将不同对象、不同模块之间的共同业务集中解决
通过动态代理的方式，把抽离出来的共性代码"织入"到业务代码中，实现对原有代码的增强处理

切入点表达式常用的模糊查询

①public * addNewUser(entity.User)："*"表示匹配所有类型的返回值

②public void *(entity.User)："*"表示匹配所有方法名

③public void addNewUser(..)：".."表示匹配任意参数个数和类型

④*com.service.*.*(..)：匹配com.service包下所有类的所有方法

⑤*com.service..*.*(..)：匹配com.service包及其子包下所有类的所有方法

AOP相关术语

AOP中常见的增强处理类型及其特点：

前置增强（Before advice）：在目标方法执行之前执行的增强处理。可以用于执行一些准备工作或进行参数验证等操作。

后置增强（After returning advice）：在目标方法成功执行之后执行的增强处理。可以用于执行一些清理工作或获取返回结果等操作。

异常增强（After throwing advice）：在目标方法抛出异常时执行的增强处理。可以用于进行异常处理或记录日志等操作。

最终增强（After finally advice）：无论目标方法是否正常返回或抛出异常，最终增强都会执行。可以用于释放资源或进行一些必要的收尾工作。

环绕增强（Around advice）：在目标方法前后都执行的增强处理。可以完全控制目标方法的执行过程，包括是否执行目标方法、修改传入参数、捕获返回结果等操作。

使用Spring AOP实现日志输出

1.先导入这五个jar包的坐标

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

2.编写切面

在切面里面写上这5个通知

@Before("execution(* service..*.*(..))")
    public void before(){
        //在方法之前要执行的公共代码放在这里
        System.out.println("前置通知.....");
    }
 
    /**
     * 后置通知
     * @param returnVal,切点方法执行后的返回值
     */
    @AfterReturning(value = "execution(* service..*.*(..))",returning = "returnVal")
    public void AfterReturning(Object returnVal){
        System.out.println("后置通知......"+returnVal);
    }
 
    /**
     * 环绕通知
     * @param joinPoint 可用于执行切点的类
     * @return
     * @throws Throwable
     */
    @Around("execution(* service..*.*(..))")
    public Object around(ProceedingJoinPoint joinPoint)throws Throwable{
        System.out.println("环绕通知前.....");
        Object obj=(Object) joinPoint.proceed();
        System.out.println("环绕通知后......");
        return obj;
    }
 
    /**
     * 抛出异常
     * @param e
     */
    @AfterThrowing(value = "execution(* service..*.*(..))",throwing = "e")
    public void afterThrowable(Throwable e){
        System.out.println("出现异常:msg="+e.getMessage());
    }
 
    /**
     * 无论什么情况下都会执行的方法
     */
    @After(value = "execution(* service..*.*(..))")
    public void after(){
        //方法的对象的关闭
        //方法的回滚
        System.out.println("最终通知....");
    }

然后在配置文件里去依赖注入

    <bean id="myAspest" class="aspect.MyAspect"></bean>
        <!--开启注解-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

总结

赞zz

关注

1
点赞
踩
0

收藏

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

分享到 QQ

分享到新浪微博

扫一扫

初识 Spring

一、什么是Spring框架

是一个轻量级的企业级应用框架

企业应用开发的"一站式"选择，贯穿于表现层、业务层、持久层

二、Spring框架的优点

低侵入式设计

独立于各种应用服务器

依赖注入特性将组件关系透明化，降低耦合度

面向切面编程特性允许将通用任务进行集中式处理

与第三方框架的良好整合