Spring笔记

spring

1.创建项目

GroupID是项目组织唯一的标识符， 比如我的项目叫test001  那么GroupID应该是 com.lixiaoming.test001 域名.公司名.项目名
ArtifactID就是项目的唯一的标识符， 一般是 项目名-xxx   比如test001-model

2.配置文件

开启自动装配
< context:annotation-config/>
指定要扫描的包，这个包下面的注解才会生效
<context:component-scan base-package="xxx.xxx"/>

有了< context:component-scan>，另一个< context:annotation-config/>标签可以移除掉，因为已经被包含进去了。

2.1 头文件

<?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
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">

<context:component-scan base-package="com.gyk"/>

</beans>

3.注解

3.1@AutoWired

默认是byType方式，如果匹配不上，就会byName

public class People {
    @Autowired
    private Cat cat;
}

3.2@Nullable

字段标记了这个注解，说明该字段可以为空

public name(@Nullable String name){}

3.3@Autowired+@Qualifier

@Autowired不能唯一装配时，需要@Autowired+@Qualifier

public class People {
    @Autowired
    private Cat cat;
    @Autowired
    @Qualifier(value = "dog")
    private Dog dog;
    private String name;
}

3.4@Resource

默认是byName方式，如果匹配不上，就会byType

public class People {
    Resource(name="cat")
    private Cat cat;
    Resource(name="dog")
    private Dog dog;
    private String name;
}

@Resource和@Autowired的区别：

• 都是用来自动装配的，都可以放在属性字段上
• @Autowired通过byType的方式实现，而且必须要求这个对象存在【常用】
• @Resource默认通过byname的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！【常用】
• 执行顺序不同：@Autowired通过byType的方式实现。@Resource默认通过byname的方式实现

3.5@Component

等价于<bean id="user" classs"pojo.User"/>

@Component
public class User {  
     public String name ="秦疆";
}

@Component有几个衍生注解，会按照web开发中，mvc架构中分层。

• dao （@Repository）
• service（@Service）
• controller（@Controller）
  这四个注解的功能是一样的，都是代表将某个类注册到容器中

4.作用域

//原型模式prototype，单例模式singleton（sping默认）
//scope("prototype")相当于<bean scope="prototype"></bean>
@Component 
@scope("prototype")
public class User { 
    
    //相当于<property name="name" value="kuangshen"/> 
    @value("kuangshen") 
    public String name; 
    
    //也可以放在set方法上面
    @value("kuangshen")
    public void setName(String name) { 
        this.name = name; 
    }
}

5.动态代理

5.1抽象角色

public interface Rent {
    public void rent();
}

5.2真实角色

public class Host implements Rent{ 
    @Override
    public void rent() {
        System.out.println("出租房子");
    }
}

5.3代理角色

public class ProxyInvocationHandler implements InvocationHandler {
    private Object target;

    public void setTarget(Object target){
        this.target=target;
    }

    //生成代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this );
    }

    //proxy： 代理类
    //method : 代理类的调用处理程序的方法对象
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(target, args);
        return result;
    }
}

5.4测试类

public class Client {
    public static void main(String[] args) {
        Host host = new Host();
        ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
        proxyInvocationHandler.setTarget(host);
        Rent proxy = (Rent) proxyInvocationHandler.getProxy();
        proxy. rent();
    }
}

6AOP

AOP( Aspect Oriented Programming), 面向切面编程,通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。 利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

横切关注点
 跨越应用程序多个模块的方法或功能，如日志 , 安全 , 缓存 , 事务等。
切面
 横切关注点被模块化的特殊对象，是个类。
通知
切面中的一个方法
目标
被通知的对象
代理
像目标对象应用通知之后创建的对象

6.1使用aop需要导包

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

6.2 AOP实现方式

6.2.1  通过 Spring API 实现

Spring配置

<?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
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--注册bean-->
    <bean id="userService" class="com.gyk.service.UserServiceImpl"/>
    <bean id="log" class="com.gyk.log.Log"/>
    <bean id="afterLog" class="com.gyk.log.AfterLog"/>
<!--aop的配置-->
    <aop:config>
    <!--切入点 expression:表达式匹配要执行的方法-->
        <aop:pointcut id="pointcut" expression="execution(*
com.gyk.service.UserServiceImpl.*(..))"/>
    <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

6.2.2   自定义类来实现Aop

自定义切入类

public class DiyPointcut {
    public void before(){
        System.out.println("---------方法执行前---------");
    } 
    public void after(){
        System.out.println("---------方法执行后---------");
    }
}

Spring配置

<!--第二种方式自定义实现-->
<!--注册bean-->
<bean id="diy" class="com.kuang.config.DiyPointcut"/>
<!--aop的配置-->
<aop:config>
    <!--第二种方式：使用AOP的标签实现-->
    <aop:aspect ref="diy">
        <aop:pointcut id="diyPonitcut" expression="execution(*
com.kuang.service.UserServiceImpl.*(..))"/>
        <aop:before pointcut-ref="diyPonitcut" method="before"/>
        <aop:after pointcut-ref="diyPonitcut" method="after"/>
    </aop:aspect>
</aop:config>

6.2.3   注解方式实现Aop

@Aspect
public class AnnotationPointcut {
    @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("---------方法执行前---------");
    } 

    @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("---------方法执行后---------");
    }

    @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        System.out.println("签名:"+jp.getSignature());
        //执行目标方法proceed
        Object proceed = jp.proceed();
        System.out.println("环绕后");
        System.out.println(proceed);
    }
}

Spring配置文件

 <!--第三种方式:注解实现-->
<bean id="annotationPointcut" class="com.kuang.config.AnnotationPointcut"/>
<aop:aspectj-autoproxy/>

7.Spring-Mybatis整合

7.1导入整合包

 <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>2.0.2</version>
</dependency>

7.2 配置工厂bean

spring-mybatis配置文件

<!--配置数据源：数据源有非常多，可以使用第三方的，也可使使用Spring的-->
<bean id="dataSource"
         class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/test?
useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
</bean>

<bean id="sqlSessionFactory"
        class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
         <!--关联Mybatis-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
</bean>

<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
    <constructor-arg index="0" ref="sqlSessionFactory" />
</bean>

<bean id="userMapper" class="com.gyk.UserMapperImpl">
    <property name="sqlSession" ref="sqlSession" />
</bean>

mybatis配置文件

<?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.gyk.pojo"/>
    </typeAliases>

    <mappers>
        <package name="com.gyk.dao"/>
    </mappers>
</configuration>

mapper文件

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

mapper.xml文件

<?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.gyk.dao.UserMapper">
    <select id="selectUser" resultType="User">
            select * from user
    </select>
</mapper>

UserMapperImpl文件

public class UserMapperImpl implements UserMapper {

    private SqlSessionTemplate sqlSession;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }

    @Override
    public List<User> selectUser() {
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

Test类

public class Test {
    @org.junit.Test
    public void selectUser() throws IOException {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("aplicationContext.xml");
        UserMapper userMapper = ctx.getBean("userMapper", UserMapper.class);
        for (User user : userMapper.selectUser()) {
            System.out.println(user);
        }
    }
}