Spring入门指南

Resource resource = new ClassPathResource("applicationContext.xml");

BeanFactory factory = new XmlBeanFactory(resource);  

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(String configLocation);

ApplicationContext applicationContext = new FileSystemXmlApplicationContext(String configLocation);

<!--指定Spring配置文件的位置，有多个配置文件时，以逗号分隔-->

<context-param>

    <param-name>contextConfigLocation</param-name>

    <!--spring将加载spring目录下的applicationContext.xml文件-->

    <param-value>

        classpath:spring/applicationContext.xml

    </param-value>

</context-param>

<!--指定以ContextLoaderListener方式启动Spring容器-->

<listener>

    <listener-class>

        org.springframework.web.context.ContextLoaderListener

    </listener-class>

</listener>

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

    <bean id="user" class="com.wyl.pojo.User">

        <property name="name" value="王延领"/>

    </bean>

</beans>

public class User { 

    private String name; 

    public User() {

        System.out.println("user无参构造方法");

    } 

    public void setName(String name) {

        this.name = name;

    } 

    public void show(){

        System.out.println("name="+ name );

    }

}

@Test

public void test(){

    ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

    //在执行getBean的时候, user已经创建好了 , 通过无参构造

    User user = (User) context.getBean("user");

    //调用对象的方法 .

    user.show();

}

<!-- 1\. 默认构造函数，如果类中没有默认构造函数则无法创建对象;bean标签中只有id和class就默认使用构造函数创建对象 -->

<bean id="userService" class="com.wyl.pojo.User"/>

<!-- 第一种根据index参数下标设置 -->

<bean id="userService" class="com.wyl.pojo.User">

    <!-- index指构造方法 , 下标从0开始 -->

    <constructor-arg index="0" value="wyl"/>

</bean>

<!-- 第二种根据参数名字设置 -->

<bean id="userService" class="com.wyl.pojo.User">

    <!-- name指参数名 -->

    <constructor-arg name="name" value="wyl"/>

</bean>

<!-- 第三种根据参数类型设置 -->

<bean id="userService" class="com.wyl.pojo.User">

    <constructor-arg type="java.lang.String" value="wyl"/>

</bean>

<!-- 2\. 使用工厂中的方法创建对象;工厂中有一个方法可以创建对象，先创建工厂对象，通过factory-bean指向工厂，使用factory-method方法获取对象 -->

<bean id="beanFactory" class="org.factory.BeanFactory"/>

<bean id="userService" factory-bean="beanFactory" factory-method="getUserService"/>

<!-- 3\. 使用静态工厂中的静态方法创建对象 -->

<bean id="userService" class="org.factory.StaticBeanFactory" factory-method="getUserService"/>

<!--  别名 : 如果添加了别名，我们也可以使用别名获取到这个对象 -->

<alias name="User" alias="u1"></alias>

<!--

  bean标签常用属性：

id属性：起名称，id属性值名称任意命名，不能包含特殊符号

class属性：创建对象所在类的全路径

name属性：功能和id属性一样的，但是在name属性值里面可以包含特殊符号

scope属性

singleton：默认值，单例

prototype：多例

request：创建对象把对象放到request域里面

session：创建对象把对象放到session域里面

globalSession：创建对象把对象放到globalSession里面

  -->

<bean id="UserT" class="com.wyl.pojo.User" scope="singleton" name="u2 u21,u22;u23">

    <property name="name" value="123"/>

</bean>

<import resource="beans.xml"/>

<bean id="..." class="..." scope="singleton"/>

public class UserBean {

    private String name;  

    public UserBean(){  

        System.out.println("UserBean()构造函数");  

    }  

    public String getName() {  

        return name;  

    }  

    public void setName(String name) {  

        System.out.println("setName()");  

        this.name = name;  

    }  

    public void init(){  

        System.out.println("this is init of UserBean");  

    }  

    public void destory(){  

        System.out.println("this is destory of UserBean " + this);  

    }  

}

<bean id="user_singleton" class="com.wyl.userBean" scope="singleton" 

            init-method="init" destroy-method="destory" lazy-init="true"/>

<beans default-lazy-init="true">

public class LifeTest {

    @Test 

    public void test() {

        AbstractApplicationContext container = 

        new ClassPathXmlApplicationContext("user.xml");

        UserBean user = (UserBean)container.getBean("user_singleton");

        System.out.println(user);

        container.close();

    }

}

<bean id="user_prototype" class="com.bean.UserBean" scope="prototype" init-method="init" destroy-method="destroy"/>

public class UserTest {

    @Test 

    public void test() {

        AbstractApplicationContext container = new ClassPathXmlApplicationContext("User.xml");

        UserBean User1 = (UserBean)container.getBean("User_singleton");

        System.out.println(User1);

        UserBean User2 = (UserBean)container.getBean("User_prototype");

        System.out.println(User2);

        container.close();

    }

}

private String name;

private Integer age;

private Date birthday;

// 构造函数

public UserServiceImpl(String name, Integer age, Date birthday) {

this.name = name;

this.age = age;

this.birthday = birthday;

}

<!-- name：按字段名称辅助；index：字段索引，给第几个字段赋值；type：指定注入值的类型，该类型也是构造函数中某个或某些字段的类型； -->

<!-- value:要注入的值，基本类型和String；ref：注入其他类型数据，指向外部bean对象;这个外部bean需要存在于Spring容器 -->

<bean id="userService" class="org.service.impl.UserServiceImpl">

    <constructor-arg name="name" value="张三"/>

    <constructor-arg name="age" value="12"/>

    <constructor-arg name="birthday" ref="date"/>

</bean>

<!-- 创建日期对象 -->

<bean id="date" class="java.util.Date"/>

private String name;

private Integer age;

private Date birthday;

public void setName(String name) {

    this.name = name;

}

public void setAge(Integer age) {

    this.age = age;

}

public void setBirthday(Date birthday) {

    this.birthday = birthday;

}

<bean id="userService2" class="org.service.impl.UserServiceImpl2">

    <property name="name" value="李四"/>

    <property name="age" value="12"/>

    <property name="birthday" ref="date"/>

</bean>

<!-- 创建日期对象 -->

<bean id="date" class="java.util.Date"/>

<!-- 注入对象类型属性 -->

<!-- 1 配置service和dao对象 -->

<bean id="userDao" class="cn.ioc.UserDao"></bean>

<bean id="userService" class="cn.ioc.UserService">

    <!-- 注入dao对象-->

    <property name="userDao" ref="userDao"></property>

</bean>

<!-- 注入复杂类型属性值 -->

  <bean id="person" class="cn.property.Person">

    <!-- 数组 -->

    <property name="arrs">

       <list>

         <value>小王</value>

         <value>小马</value>

         <value>小宋</value>

       </list>

    </property>

    <!-- list -->

    <property name="list">

       <list>

         <value>小奥</value>

         <value>小金</value>

         <value>小普</value>

       </list>      

    </property>

    <!-- map -->

    <property name="map">

       <map>

         <entry key="aa" value="lucy"></entry>

         <entry key="bb" value="mary"></entry>

         <entry key="cc" value="tom"></entry>

       </map>

    </property>

    <!-- properties -->

    <property name="properties">

       <props>

         <prop key="driverclass">com.mysql.jdbc.Driver</prop>

         <prop key="username">root</prop>

       </props>

    </property>

  </bean>

<!--set-->

<property name="set">

            <set>

                <value>LOL</value>

                <value>COC</value>

                <value>WOW</value>

            </set>

</property>

<!--null-->

<property name="marne">

            <null/>

</property>

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

</beans>

<!-- p命名空间注入，可以直接注入属性的值：property -->

<bean id="User"  class="com.wyl.pojo.User" p:name ="老秦" p:age ="18"/>

<!-- c命名空间注入，通过构造器注入：construct-args -->

<bean id="User2" class="com.wyl.pojo.User" c:age="18" c:name="老李"/>

<!--

byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid！

-->

<bean id="people" class="com.wyl.pojo.People" autowire="byName">

    <property name="name" value="wangyanling"/>

</bean>

<bean id="cat" class="com.wyl.pojo.Cat"/>

    <bean id="dog" class="com.wyl.pojo.Dog"/>

    <!--

    byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid！

    byType：会自动在容器上下文中查找，和自己对象属性类型相同的bean！

    -->

    <bean id="people" class="com.wyl.pojo.People" autowire="byType">

        <property name="name" value="WANGAYNLING"/>

    </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: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:annotation-config/>

</beans>

 @Autowired

    private Cat cat;

    @Autowired

    private Dog dog;

@Nullable     // 字段标记了这个注解，说明这个字段可以为null

public class People {

    private String name;

    @Autowired

    @Qualifier("cat")

    private Cat cat;

    @Autowired

    @Qualifier("dog")

    private Dog dog;

}

public class People {

    private String name;

    @Resource(name = "cat")

    private Cat cat;

    @Resource(name = "dog")

    private Dog dog;

@PostConstruct

public void init() {

    System.out.println("初始化注解");

}

@PreDestroy

public void destroy() {

    System.out.println("销毁注解");

}

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

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(classes = ApplicationConfig.class) 纯注解

// @ContextConfiguration(locations = "classpath:ApplicationContext.xml") xml配置文件

public class SpringTest {

    @Autowired

    private AccountServiceImpl accountService;

    @Test

    public void findAll(){

        List<Account> accountList = accountService.findAll();

        for (Account account : accountList) {

            System.out.println(account);

        }

    }

}

public class User {

    private Integer id;

    private String name;

}

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

       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="user" class="com.wyl.bean.User" >

        <property name="id" value="1"></property>

        <property name="name" value="wyl"></property>

    </bean>

</beans>

@test

public void UserTest{

ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("Bean.xml");

        User userInfo=(User)context.getBean("user");

        System.out.println(userInfo);

}

@Configuration

public class MyTestConfig {

    //bean的id默认为方法名

    @Bean

    public User user(){

        User user =new User();

        user.setName("王延领");

        user.setId(2);

        return user;

    }

}

@test

public void UserTest{

    AnnotationConfigApplicationContext context=new                          AnnotationConfigApplicationContext(MyTestConfig.class);

        User userInfo=(User)context.getBean("user");

        System.out.println(userInfo.toString());

        }

    public interface Rent {

    public void rent();

}

    public class Host implements Rent{

    @Override

    public void rent() {

        System.out.println("房东出租房子！");

    }

}

    public class Proxy {

    private Host host;

    public Proxy(){

    }

    public Proxy(Host host){

        this.host=host;

    }

    public void rent(){

        seeHouse();

        host.rent();

        hetong();

        fare();

    }

    public void seeHouse(){

        System.out.println("中介带你看房");

    }

    public void fare(){

        System.out.println("收中介费!");

    }

    public void hetong(){

        System.out.println("签租领合同");

    } 

}

public class Client {

    public static void main(String[] args) {

        Host host=new Host();

        //host.rent();

        Proxy proxy=new Proxy(host);

        proxy.rent();

    }

}

    //抽象角色：租房

public interface Rent {

    public void rent();

}

//真实角色: 房东，房东要出租房子

public class Host implements Rent{

    public void rent() {

        System.out.println("房屋出租");

    }

}

//代理:中介

public class ProxyInvocationHandler implements InvocationHandler {

    private Rent rent;

    public void setRent(Rent rent) {

        this.rent = rent;

    }

    //生成代理类，重点是第二个参数，获取要代理的抽象角色！之前都是一个角色，现在可以代理一类角色

    public Object getProxy(){

        return Proxy.newProxyInstance(this.getClass().getClassLoader(),

                rent.getClass().getInterfaces(),this);

    }

    // proxy : 代理类 method : 代理类的调用处理程序的方法对象.

    // 处理代理实例上的方法调用并返回结果

    @Override

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        seeHouse();

        //核心：本质利用反射实现！

        Object result = method.invoke(rent, args);

        fare();

        return result;

    }

    //看房

    public void seeHouse(){

        System.out.println("带房客看房");

    }

    //收中介费

    public void fare(){

        System.out.println("收中介费");

    }

}

//租客

public class Client {

    public static void main(String[] args) {

        //真实角色

        Host host = new Host();

        //代理实例的调用处理程序

        ProxyInvocationHandler pih = new ProxyInvocationHandler();

        pih.setRent(host); //将真实角色放置进去！

        Rent proxy = (Rent)pih.getProxy(); //动态生成对应的代理类！

        proxy.rent();

    }

}

// 被代理的对象

Account account = new Account();

Account o = (Account) Enhancer.create(account.getClass(), new MethodInterceptor() {

    /**

    * 被代理对象的方法执行前会执行
    * @param obj 被代理的对象
    * @param method 方法
    * @param objects 参数
    * @param methodProxy 当前执行方法的代理的对象
    * @return 和被代理对象的方法相同的返回值
    * @throws Throwable 异常
    */
    @Override
    public Object intercept(Object obj, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("增强前...");
        Object invoke = method.invoke(account, objects);
        System.out.println("增强后...");
        return invoke;
    }
});
o.findAll();

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->

<dependency>

    <groupId>org.aspectj</groupId>

    <artifactId>aspectjweaver</artifactId>

    <version>1.9.4</version>

</dependency>

//接口与业务

public interface UserService {

    public void add();

    public void delete();

    public void update();

    public void search();

} 

public class UserServiceImpl implements UserService{

    @Override

    public void add() {

        System.out.println("增加用户");

    }

    @Override

    public void delete() {

        System.out.println("删除用户");

    }

    @Override

    public void update() {

        System.out.println("更新用户");

    }

    @Override

    public void search() {

        System.out.println("查询用户");

    }

}

//增强

public class AfterLog implements AfterReturningAdvice {

    //returnValue 返回值

    //method被调用的方法

    //args 被调用的方法的对象的参数

    //target 被调用的目标对象

    @Override

    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {

        System.out.println("执行了" + target.getClass().getName()

        +"的"+method.getName()+"方法,"

        +"返回值："+returnValue);

    }

}

<?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.wyl.service.UserServiceImpl"/>

    <bean id="log" class="com.kuang.log.Log"/>

    <bean id="afterLog" class="com.kuang.log.AfterLog"/>

    <!--aop的配置-->

    <aop:config>

        <!--切入点  expression:表达式匹配要执行的方法-->

        <aop:pointcut id="pointcut" expression="execution(* com.wyl.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>

public class MyTest {

    @Test

    public void test(){

        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        UserService userService = (UserService) context.getBean("userService");

        userService.search();

    }

}

//切入类

public class DiyPointcut {

    public void before(){

        System.out.println("---------方法执行前---------");

    }

    public void after(){

        System.out.println("---------方法执行后---------");

    }

}

<!--第二种方式自定义实现-->

<!--注册bean-->

<bean id="diy" class="com.wyl.config.DiyPointcut"/

<!--aop的配置-->

<aop:config>

    <!--第二种方式：使用AOP的标签实现-->

    <aop:aspect ref="diy">

        <aop:pointcut id="diyPonitcut" expression="execution(* com.wyl.service.UserServiceImpl.*(..))"/>

        <aop:before pointcut-ref="diyPonitcut" method="before"/>

        <aop:after pointcut-ref="diyPonitcut" method="after"/>

    </aop:aspect>

</aop:config>

public class MyTest {

    @Test

    public void test(){

        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        UserService userService = (UserService) context.getBean("userService");

        userService.add();

    }

}

//注解实现的增强类

package com.wyl.config;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.After;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

@Aspect

public class AnnotationPointcut {

    @Before("execution(* com.wyl.service.UserServiceImpl.*(..))")

    public void before(){

        System.out.println("---------方法执行前---------");

    }

    @After("execution(* com.wyl.service.UserServiceImpl.*(..))")

    public void after(){

        System.out.println("---------方法执行后---------");

    }

    @Around("execution(* com.wyl.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自带的数据源

DriverManagerDataSource dataSource = new DriverManagerDataSource();

dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");

dataSource.setUrl("jdbc:mysql://localhost:3306/spring?useSSL=false&allowPublicKeyRetrieval=true&serverTimezone=Asia/Shanghai");

dataSource.setUsername("root");

dataSource.setPassword("root");

JdbcTemplate template = new JdbcTemplate(dataSource);

List<Account> accountList = template.query("select * from account", new BeanPropertyRowMapper<>(Account.class));

for (Account account : accountList) {

    System.out.println(account);

}

@Autowired

private JdbcTemplate jdbcTemplate;

// 添加

@Test

public void insert(){

    String sql = "insert into account(name, money) VALUES (?,?)";

    Account account1 = new Account();

    account1.setName("迪迦");

    account1.setMoney(10000F);

    jdbcTemplate.update(sql, account1.getName(), account1.getMoney());

    find();

}

// 删除

@Test

public void delete(){

    String sql = "delete from account where id = ?";

    jdbcTemplate.update(sql, 6);

    find();

}

// 更新

@Test

public void update(){

    List<Account> accounts = jdbcTemplate.query("select * from account where id = ?", new BeanPropertyRowMapper<>(Account.class), 1);

    Account account = accounts.get(0);

    account.setName("泰罗");

    String sql = "update account set name = ? where id = ?";

    jdbcTemplate.update(sql, account.getName(),account.getId());

    find();

}