Spring零基础入门笔记（Idea版）
导入jar
spring的
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.2.7.RELEASE</version> </dependency>
多个版本的Spring
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.2.6.RELEASE</version> </dependency>
连接Mybatis 的jar
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.2.7.RELEASE</version> </dependency>
优点：
是一个开源免费的框架
是一个轻量级非入侵式的框架
控制反转和面向切面编程
支持事务处理，对于框架的整合的支持
总结：一个轻量级控制反转，和面向切面的框架。
组成
IOC推导
set注入对象可以实现对于对象的时刻变化
IOc的原型是可以将对执行的对象传入进来
IOC的本质
构造器的使用：
默认调用无参构造器
调用有参构造器
1.下标
2.类型
3.通过参数的名称
Spring 配置
别名
可以在getbeans的地方传入的参数为别名
beans配置
导入
用于团队合作，将多个文件合并成一个
合并于一个 总文件里面
依赖注入
构造器注入
前面讲过
set注入
1.依赖：bean的对象创建依赖于容器
2.注入：bean对象的属性由容器来注入
c:命名空间与P：命名空间
注意点：使用前导入xml的约束：xmlns:c="http://www.springframework.org/schema/c"
Bean作用域
单例模式：Spring 的默认模式
原型模式：每次从容器里面getbeans 的时候都会产生一个新的对象
Beans的自动装配
自动装配满足bean依赖的一种方式：寻找bean -->装配
三种：
1.xml显示配置
以上学测都是javabean的装配
2.java代码显示配置
3.隐式的装配bean
3.1 autowrie=byname的方式（保证bean 的id唯一并且setxxx的xxx一致）
会自动查找和自己对象set方法对应的值的（beans里面的）id
3.2
会在容器里面查找 会在beans里面类型相同的类型自动装配（类型全局唯一） 根据class=“类型“
使用：需要保证beans的里面的class唯一并且需要beans 的自定注入的属性值类型一样
使用注解
jdk1.5实现注解 Spring实现注解
使用须知：
1.导入约束
2.配置注解支持
直接在属性上导入注解：需要bean的id为属性名字是通过autowried=byname实现的
可以在set上面使用 使用自动装配可以不使用set方法
补充：@Nullable String可以为空
@Autowried
源码
可以@Autowried（requird=false）
如果显示的定义了required 说明对象可以为null
@Qualifier（）
通过beans 的id注入对象
@Qualifier(value = "cat12312312")
@Autowired
是一对
@Resoures （）
首先是byname 其次是bytype进行自动注入
@Nullable
可以让属性为null值
@component
放在类上代替了在xml中写beans
但是需要在xml中书写
<context:component-scan base-package="com.cqf.pojo"/>
<context:annotation-config></context:annotation-config>
@value（value）
给属性注解或者给set方法上面
@Scope（“类型”）
设置作用域
注解开发
前提导入apo的jar
注解的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">
</beans>
bean
属性注入
类似于beans里面的properties name value
衍生注解
@Component 的衍生注解 实在web开发的过程中
dao @Repository
service @Serverce
controller @Controller
前提要在xml中扫描包
<context:component-scan base-package="com.cqf"/>
自动装配
作用域
@Scope（'模式'）
小结：
最佳实现：xml管理bean 而注解完成属性的注入
前提 ：开启context 的xml约束 ---开启注解支持---扫描包下的内容
补充：完全使用java的配置bean
不需要xml配置
@Configuration
这是一个而配置类 相当于xml的beans 吧对象注册到容器中 因为本省就是一个组件
config的方法的名字就相当于的bean 的id
@bean相当于在xml写一个bean抱歉
return 返回出bean 的对象
需要在bean对象里面
进行扫描包
@@ConfigurationScan（包名）
获取容器的方法！！有变化
@improt 引入配置类的对象
AOP
代理模式
静态代理模式
优点：可以让真实的角色更叫纯粹，不用去关注一些公共的业务
公共的交给代理 实现了业务的分工
公共业务的发生了扩展是可以集中的管理
public interface Action {
public void info();
}
public class Agent {
private Loador loador;
public Agent(Loador loador) {
this.loador = loador;
}
public Agent() {
}
public void Agentaction(){
loador.info();
action();
}
public void action(){
System.out.println("hand out tips");
}
}
public class Loador implements Action{
@Override
public void info() {
System.out.println("l want put it out");
}
}
public class Peopletest {
public static void main(String[] args) {
Loador loador = new Loador();
Agent agent = new Agent(loador);
agent.Agentaction();
}
}
动态代理
基于类的动态代理：jdk的代理
基于类的动态代理：cglib
基于java字节码：javassist
需要了解的两个类：Proxy InvocationHandler
优点：可以让真实的角色更叫纯粹，不用去关注一些公共的业务
公共的交给代理 实现了业务的分工
公共业务的发生了扩展是可以集中的管理
一个动态代理对象代理的都是接口 实现一类的业务
一个代理类实现多个类 只要实现同一个接口即可
源码：https://github.com/cqf073/proxy_pattern_super
名词解释
使用Spirng的接口
使用Spring的API实现
切入点实现
接口
public interface UserService {
//api接口实现
public void add();
public void delete();
public void updata();
public void query();
}
接口实现类
public class UserServiceImpl implements UserService {
@Override
public void add() {
System.out.println("Add");
}
@Override
public void delete() {
System.out.println("Delate");
}
@Override
public void updata() {
System.out.println("updata");
}
@Override
public void query() {
System.out.println("query");
}
}
日志前/后
public class AfterLog implements AfterReturningAdvice{
//执行目标对象的方法 args参数 target执行的对象
// @Override
// public void before(Method method, Object[] args, Object target) throws Throwable {
// System.out.println(target.getClass().getName()+"的"+method.getName());
// }
//o 未返回值 o1位target
@Override
public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
System.out.println("______________");
System.out.println("after");
System.out.println(method.getName());
}
}
blic class Log implements MethodBeforeAdvice{
//执行目标对象的方法 args参数 target执行的对象
@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println("______________");
System.out.println("before");
System.out.println(target.getClass().getName()+"的"+method.getName());
}
}
xml配置
<!--注册bean-->
<bean id="userservice" class="com.cqf.service.UserServiceImpl"/>
<bean id="log" class="com.cqf.log.Log"/>
<bean id="after" class="com.cqf.log.AfterLog"/>
<!--配置aop-->
<aop:config>
<!--切入点execution(要执行 的位置)-->
<aop:pointcut id="p" expression="execution(* com.cqf.service.UserServiceImpl.*(..))"></aop:pointcut>
<!--执行环绕增强-->
<aop:advisor advice-ref="log" pointcut-ref="p"/>
<aop:advisor advice-ref="after" pointcut-ref="p"/>
</aop:config>
</beans>
测试类
public class Mytest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
// 代理的一定是接口
UserService userservice = (UserService)context.getBean("userservice");
userservice.delete();
}
}
diy的切入面
xml
<bean id="idy" class="com.cqf.DIY.DIYpointcut"></bean>
<aop:config>
<aop:aspect ref="idy">
<!--切入点-->
<aop:pointcut id="aop" expression="execution(* com.cqf.service.UserServiceImpl.*(..))"/>
<aop:before method="before" pointcut-ref="aop"/>
<aop:after method="after" pointcut-ref="aop"/>
</aop:aspect>
</aop:config>
</beans>
java类
public class DIYpointcut {
//通知
public void before(){
System.out.println("方法执行之前");
}
public void after(){
System.out.println("方法执行之后");
}
}
使用注解实现
面向切面的注解
@Aspect
public class MethodAnnoution {
@Before("execution(* com.cqf.service.UserServiceImpl.*(..))")
public void before(){
System.out.println("brfore");
}
@After("execution(* com.cqf.service.UserServiceImpl.*(..))")
public void after(){
System.out.println("After");
}
//在环绕的时候需要给定一个参数代表我们需要环绕的点
@Around("execution(* com.cqf.service.UserServiceImpl.*(..))")
public void around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("before-around");
joinPoint.proceed();
System.out.println("After-around");
}
}
xml的注册
<bean id="method" class="com.cqf.DIY.MethodAnnoution"/>
<!--开启注解支持-->
<aop:aspectj-autoproxy/>
</beans>
整合mybatis
导入jar
junit mybatis sql连接 spring 相关 aop植入 mybatis-spring
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.19</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.3</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.2.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.6.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.1.9.RELEASE</version>
</dependency>
<dependency>
<groupId>aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.5.3</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.3</version>
</dependency>
</dependencies>
回忆mybatis
1.编写实体类
@Data
public class User {
private String name;
private int id;
private String pwd;
}
2.编写配置文件
<?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>
<typeAliases>
<package name="com.cqf.pojo"/>
</typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/smbms?useSSL=true&useUnicode=true&characterEncodeing=UTF-8&serverTimezone=GMT"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper class="com.cqf.dao.UserMapper"></mapper>
</mappers>
</configuration>
3.编写接口
public interface UserMapper {
public List<User> get();
}
4.编写mapper
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cqf.dao.UserMapper">
<select id="get" resultType="user">
SELECT * FROM mybatis.user
</select>
</mapper>
5.测试
@Test
public void getuser() throws IOException {
String s="MybatisConfig.xml";
InputStream resourceAsStream = Resources.getResourceAsStream(s);
SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsStream);
SqlSession sqlSession = build.openSession(true);
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> users = mapper.get();
for (int i = 0; i <users.size() ; i++) {
System.out.println(users.get(i));
}
}
6.可能出现的问题
6.1数据库的时区问题
<property name="url" value="jdbc:mysql://localhost:3306/smbms?useSSL=true&useUnicode=true&characterEncodeing=UTF-8&serverTimezone=GMT"/>
6.2没有进行静态过滤问题
<build>
<resources>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
</build>
Mybatis-spring
1.编写数据配置
2.sqlsessionfactory
3.sqlsessiontemplate
4.给接口添加实现类
5.实现类注入到测试使用
声明式事务
声明是事务：确保一致性与完整性。（把与业务当成一个业务做要嘛成功要嘛失败 ）
事务的ACID原则
A原子性
C一致性
I隔离性
D持久性
事务的分类
声明式事务 AOP
编程式的事务 需要在代码中进行代码的管理
propagation的属性值
实现事务的插入的xml配置
<!--通过aop实现事务的植入-->
<!--配置事务的通知-->
<tx:advice id="advice" transaction-manager="transactionManager">
<!--给什么方法配置事务-->
<!--配置事务的传播特效-->
<tx:attributes>
<!--<tx:method name="get" propagation="REQUIRED"/>-->
<!--<tx:method name="adduser" propagation="REQUIRED"/>-->
<!--<tx:method name="delete" propagation="REQUIRED"/>-->
<tx:method name="*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="cut" expression="execution(* com.cqf.dao.*.*(..))"/>
<aop:advisor advice-ref="advice" pointcut-ref="cut"/>
</aop:config>
MapperImpl
public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
//原来使用的sqlsession 的全部都使用SqlSessionTemplate
@Override
public List<User> get() {
User user = new User("x", 6, "13");
SqlSession sqlSession = getSqlSession();
UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
mapper.adduser(user);
mapper.delete(2);
return mapper.get();
}
@Override
public int adduser(User user) {
return getSqlSession().getMapper(UserMapper.class).adduser(user);
}
@Override
public int delete(int id) {
return getSqlSession().getMapper(UserMapper.class).delete(id);
}
}
