victory的博客

长安一片月，万户捣衣声

0%

发表于 分类于 ， ， ，

JdbcTemplate增删改查

1.项目目录

2.Emp.java

package com.atguigu.jdbctemplate;

public class Emp {
    private Integer eid;
    private String ename;
    private Integer age;
    private String sex;
    public Integer getEid() {
        return eid;
    }
    public void setEid(Integer eid) {
        this.eid = eid;
    }
    public String getEname() {
        return ename;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "Emp [eid=" + eid + ", ename=" + ename + ", age=" + age + ", sex=" + sex + "]";
    }
    
}

3.ssm表

4.db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm
jdbc.username=root
jdbc.password=root

5.jdbc.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 http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    
    <!-- 引入属性文件 -->
    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="db.properties"></property>
    </bean>
    
    <!-- 引入属性文件 -->
    <context:property-placeholder location="db.properties"/>
    
    <!-- 创建数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>
    
    <!-- 通过数据源配置JdbcTemplate -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    
</beans>

6.TestJdbcTemplate.java

package com.atguigu.jdbctemplate;

import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;

public class TestJdbcTemplate {
    ApplicationContext ac = new ClassPathXmlApplicationContext("jdbc.xml");
    JdbcTemplate jdbcTemplate = ac.getBean("jdbcTemplate", JdbcTemplate.class);
    
    @Test
    public void test() {
        //单个增删改
        //System.out.println(jdbcTemplate);//org.springframework.jdbc.core.JdbcTemplate@6483f5ae
        //jdbcTemplate.update("insert into emp values(1,'zhangsan',23,'男')");
        
        //增加记录
        //String sql = "insert into emp values(2, ?, ?, ?)";
        //jdbcTemplate.update(sql, "lisi", 25, "男");
        
        //删除记录
        //String sql = "delete from emp where eid=?";
        //jdbcTemplate.update(sql,2);
        
        //修改记录
        //String sql = "update emp set ename=? where eid=?"; 
        //jdbcTemplate.update(sql, "lisi", 1);
        
        //不能使用
        //String sql = "delete from emp where eid in (?)";
        //String eids = "3, 4, 5";
        //jdbcTemplate.update(sql,eids);
        
        //可以使用
        //String eids = "3,4,5";
        //String sql = "delete from emp where eid in ("+eids+")";
        //jdbcTemplate.update(sql);
        
        //String sql = "select * from emp where ename like '%?%'";//不能使用
        //String sql = "select * from emp where ename like concat('%',?,'%')";//可以使用
    }
    
    @Test
    public void testBatchUpdate(){
        //批量增删改
//        String sql = "insert into emp values(?,?,?,?)";
//        List<Object[]> list = new ArrayList<>();
//        list.add(new Object[]{3,"a1",1,"男"});
//        list.add(new Object[]{4,"a2",2,"男"});
//        list.add(new Object[]{5,"a3",3,"男"});
//        jdbcTemplate.batchUpdate(sql, list);
    }
    
    @Test
    public void testQueryForObject(){
        //jdbcTemplate.queryForObject(sql, requiredType);//用来获取单个的值
        //jdbcTemplate.queryForObject(sql, rowMapper);//用来获取单条数据
        
//        String sql= "select eid,ename,age,sex from emp where eid=?";
//        RowMapper<Emp> rowMapper = new BeanPropertyRowMapper<>(Emp.class);//将列名（字段名或字段名的别名）与属性名进行映射
//        Emp emp = jdbcTemplate.queryForObject(sql, new Object[]{3}, rowMapper);
//        System.out.println(emp);
        
        String sql = "select count(*) from emp";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        System.out.println(count);
    }
    
    @Test
    public void testQuery(){
        String sql = "select eid,ename,age,sex from emp";
        RowMapper<Emp> rowMapper = new BeanPropertyRowMapper<>(Emp.class);
        List<Emp> list = jdbcTemplate.query(sql, rowMapper);
        for(Emp emp:list){
            System.out.println(emp);
        }
    }

}

发表于 分类于 ， ， ，

以XML方式配置切面

1.项目目录

2.MathI.java(接口)

package com.atguigu.spring.aopxml;

public interface MathI {
    int add(int i, int j);
    int sub(int i, int j);
    int mul(int i, int j);
    int div(int i, int j);
}

3.MathImpl.java(实现类)

package com.atguigu.spring.aopxml;

import org.springframework.stereotype.Component;

@Component
public class MathImpl implements MathI{

    @Override
    public int add(int i, int j) {
        int result = i + j;
        return result;
    }
    
    @Override
    public int sub(int i, int j) {
        int result = i - j;
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i * j;
        return result; 
    }

    @Override
    public int div(int i, int j) {
        int result = i / j;
        return result;
    }
}

4.MyLogger.java(切面)

package com.atguigu.spring.aopxml;

import org.springframework.stereotype.Component;

@Component
public class MyLogger {
    public void before(){
        System.out.println("前置通知");
    }
}

5.aop-xml.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"
    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-4.0.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd">

    <context:component-scan base-package="com.atguigu.spring.aopxml"></context:component-scan>
    
    <!-- 以XML方式配置切面  -->
    <aop:config>
        <!-- 切面 -->
        <aop:aspect ref="myLogger">
            <!-- 前置通知 通知通过切入点表达式作用于连接点-->
            <!-- <aop:before method="before" pointcut="execution(* com.atguigu.spring.aopxml.*.*(..))"/> -->
            
            <aop:pointcut expression="execution(* com.atguigu.spring.aopxml.*.*(..))" id="cut"/>
            <aop:before method="before" pointcut-ref="cut"/>
        </aop:aspect>
    </aop:config>
</beans>

6.Test.java(测试类)

package com.atguigu.spring.aopxml;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("aop-xml.xml");
        MathI math = ac.getBean("mathImpl", MathI.class);
        int add = math.add(2, 2);
        System.out.println(add);
    }

}

7.运行结果

前置通知
4

发表于 分类于 ， ， ，

动态代理-数学计算器

项目目录

1.要求
1）计算器能够执行加减乘除运算
2）日志：在程序执行期间追踪正在发生的活动
3）验证：希望计算器只能处理正数的运算

2.常规实现

**MathI.java**
package com.atguigu.proxy;

public interface MathI {
    int add(int i, int j);
    int sub(int i, int j);
    int mul(int i, int j);
    int div(int i, int j);
}

MathImpl.java

package com.atguigu.proxy;

public class MathImpl implements MathI{

    @Override
    public int add(int i, int j) {
        System.out.println("method:add,arguments:" + i + "," + j);
        System.out.println("method:add,results:" + (i + j));
        return i + j;
    }
    
    @Override
    public int sub(int i, int j) {
        System.out.println("method:sub,arguments:" + i + "," + j);
        System.out.println("method:sub,results:" + (i - j));
        return i - j;
    }

    @Override
    public int mul(int i, int j) {
        System.out.println("method:mul,arguments:" + i + "," + j);
        System.out.println("method:mul,results:" + (i * j));
        return i * j;
    }

    @Override
    public int div(int i, int j) {
        System.out.println("method:div,arguments:" + i + "," + j);
        System.out.println("method:div,results:" + (i / j));
        return i / j;
    }
}

常规实现方法存在的问题
①代码混乱：越来越多的非业务需求(日志和验证等)加入后，原有的业务方法急剧膨胀。每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点。
②代码分散: 以日志需求为例，只是为了满足这个单一需求，就不得不在多个模块（方法）里多次重复相同的日志代码。如果日志需求发生变化，必须修改所有模块。

3.动态代理
MathI.java（与2中的代码相同）

MathImpl.java(2中的代码中去掉日志信息)

MyLogger.java(日志类)

ProxyUtil.java(代理类)

package com.atguigu.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class ProxyUtil{
    //代理模式：1、静态代理（代理对象真实存在，是自己写好的） 2、动态代理（动态生成代理对象，不需要自己写）
    private MathImpl mathImpl;//目标对象 目标对象类必须实现接口
    
    public ProxyUtil(MathImpl mathImpl) {
        super();
        this.mathImpl = mathImpl;
    }

    public Object getProxy(){
        //获取当前类的类加载器用来加载代理对象所属类
        ClassLoader loader = this.getClass().getClassLoader();//动态生成代理对象就需要动态代理类，代理类的执行需要类加载器
        //获取目标对象实现的所有接口的Class，代理类会和目标对象实现相同的接口，最终通过代理对象实现功能
        Class[] interfaces = mathImpl.getClass().getInterfaces();
        
        return Proxy.newProxyInstance(loader, interfaces, new InvocationHandler(){

            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //代理对象实现功能的方式
                try{
                    MyLogger.before(method.getName(), Arrays.toString(args));
                    Object result = method.invoke(mathImpl, args);//动态代理对象实现功能（调用目标对象的方法）
                    MyLogger.after(method.getName(), result);
                    return result;
                }catch (Exception e){
                    MyLogger.throwing();
                    e.printStackTrace();
                }finally{
                    System.out.println("哪都有我");
                }
                return null;
                
            }
        });
    }
}

Test.java(测试类)

package com.atguigu.proxy;

public class Test {

    public static void main(String[] args) {
//        MathI math = new MathImpl();
//        int result = math.add(1, 1);
//        System.out.println(result);
        ProxyUtil proxy = new ProxyUtil(new MathImpl());
        
        MathI math = (MathI)proxy.getProxy();
        
        int i = math.add(1, 1);
        System.out.println(i);
        
        int j = math.div(4, 0);
        System.out.println(j);
    }
}

发表于 分类于 ， ， ，

基于注解（@Autowired）的自动装配

1.项目目录

2.UserController.java

package com.atguigu.ioc.userMod.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

import com.atguigu.ioc.userMod.service.UserService;
import com.atguigu.ioc.userMod.service.UserServiceImpl;

/**
 * 基于注解的组件化管理：
 * @Component,@Controller（控制层）,@Service（业务层）,@Repository（持久曾）
 * 以上四个注解功能完全相同，不过在实际开发中，要在实现不同功能的类上加上相应的注解
 * 完成组件化管理的过程：
 * 1、在需要被spring管理的类上加上相应注解
 * 2、在配置文件中通过<context：component-scan>对所设置的包结构进行扫描，就会将加上注解的类作为spring的组件进行加载
 * 组件：指spring中管理的bean
 * 作为spring的组件进行加载：会自动在spring的配置文件中生成相对应的bean，这些bean的id会以类的首字母小写为值；
 * 也可以通过@Controller("beanId")为自动生成的bean指定id
 * 
 * 自动装配：在需要赋值的非字面量属性上，加上@Autowired注解，就可以在spring容器中，通过不同的方式匹配到相对应的bean
 * @Autowired装配时，会默认使用byType的方式，此时要求spring容器中只有一个能够为其赋值
 * 当byType实现不了装配时，会自动切换到byName,此时要求spring容器中，有一个bean的id和属性名一致
 * 若自动装配时，匹配到多个能够赋值的bean，可使用@Qualifire（value="beanId")指定使用的bean
 * @Autowired和@Qualifire（value="beanId")可以一起作用于一个带形参的方法上，此时，@Qualifire（value="beanId")所
 * 指定的bean作用于形参
 * 
 */

@Controller
//@Controller(value="aaa")//为自动创建的bean设置id
public class UserController {
    //private UserService userService = new UserServiceImpl();
    @Autowired//基于注解的自动装配(根据类型进行自动装配 byType)
    private UserService userService;
    
    public void addUser(){
        userService.addUser();
    }
    
    public UserController() {
        System.out.println("UserController");
    }
}

3.UserService.java

package com.atguigu.ioc.userMod.service;

public interface UserService {
    void addUser();
}

4.UserServiceImpl.java

package com.atguigu.ioc.userMod.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import com.atguigu.ioc.userMod.dao.UserDao;
import com.atguigu.ioc.userMod.dao.UserDaoImpl;

@Service
public class UserServiceImpl implements UserService{
    
    //private UserDao userDao = new UserDaoImpl();
    
    @Autowired
    //@Qualifier(value="userDaoImpl")
    @Qualifier(value="userDaoMybatisImpl")
    private UserDao userDao;
    
//    @Autowired
//    @Qualifier(value="userDaoMybaticImpl")
//    public void setUserDao(UserDao userDao){
//        this.userDao = userDao;
//    }
    
    public UserServiceImpl() {
        System.out.println("UserServiceImpl");
    }

    @Override
    public void addUser() {
        // TODO Auto-generated method stub
        userDao.addUser();
    }

}

5.UserDao.java

package com.atguigu.ioc.userMod.dao;

public interface UserDao {
    void addUser();
}

6.UserDaoImpl.java

package com.atguigu.ioc.userMod.dao;

import org.springframework.stereotype.Repository;

@Repository
public class UserDaoImpl implements UserDao{
    public UserDaoImpl(){
        System.out.println("UserDaoImpl");
    }

    @Override
    public void addUser() {
        System.out.println("添加成功");
    }
}

7.UserDaoMybatisImpl.java

package com.atguigu.ioc.userMod.dao;

import org.springframework.stereotype.Repository;

@Repository
public class UserDaoMybatisImpl implements UserDao{

    @Override
    public void addUser() {
        // TODO Auto-generated method stub
        System.out.println("UserDaoMybatisImple:添加成功");
    }
}

8.user.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 http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    
    <!-- 
        <context:component-scan>:扫描组件，对设置的包下面的类进行扫描，会将加上注解的类作为spring的组件进行加载
        组件：指spring中管理的bean
        作为spring的组件进行加载：会自动在spring的配置文件中生成相对应的bean，这些bean的id会以类的首字母小写为值
        
        <context:include-filter>:在设定的包结构下再次通过注解或类型具体包含到某个或某几个类
        注意：在使用包含时，一定要设置use-default-filters="false"，将默认（即扫描包下所有的类）的过滤关闭
        
        <context:exclude-filter>:在设定的包结构下，再次通过注解或类型具体排除某个或某几个类
        注意：在使用排除时，一定要设置use-default-filters="true"，将默认（即扫描包下所有的类）的过滤打开
        
        切记：一个<context:component-scan>中可以出现多个include，也可以同时出现多个exclude，但是两个不能同时出现
     -->
    <context:component-scan base-package="com.atguigu.ioc.userMod" use-default-filters="true">
        <!-- <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/> -->
        <!-- <context:include-filter type="assignable" expression="com.atguigu.ioc.userMod.service.UserServiceImpl"/> -->
        <!-- <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/> -->
        <!-- <context:exclude-filter type="assignable" expression="com.atguigu.ioc.userMod.dao.UserDaoImpl"/> -->
    </context:component-scan>
    
    <!-- <bean id="userController" class="com.atguigu.ioc.userMod.controller.UserController"></bean>
    <bean id="userServiceImpl" class="com.atguigu.ioc.userMod.service.UserServiceImpl"></bean>
    <bean id="userDaoImpl" class="com.atguigu.ioc.userMod.dao.UserDaoImpl"></bean> -->
    
    <!-- 测试@Autowired是根据类型来进行自动装配的（byType） -->
    <!-- <bean id="user" class="com.atguigu.ioc.userMod.dao.UserDaoImpl"></bean> -->
    
    <!-- 如果根据类型自动装配失败，则byName -->
    <!-- <bean id="userDao" class="com.atguigu.ioc.userMod.dao.UserDaoImpl"></bean> -->
</beans>

9.Test.java

package com.atguigu.ioc.userMod;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.atguigu.ioc.userMod.controller.UserController;
import com.atguigu.ioc.userMod.dao.UserDao;
import com.atguigu.ioc.userMod.dao.UserDaoImpl;
import com.atguigu.ioc.userMod.service.UserService;
import com.atguigu.ioc.userMod.service.UserServiceImpl;

public class Test {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("user.xml");
        
        UserController uc = ac.getBean("userController", UserController.class);
        System.out.println(uc);//com.atguigu.ioc.userMod.controller.UserController@4b553d26
        
        UserService us = ac.getBean("userServiceImpl", UserServiceImpl.class);
        System.out.println(us);//com.atguigu.ioc.userMod.service.UserServiceImpl@69a3d1d
        
        UserDao ud = ac.getBean("userDaoImpl", UserDaoImpl.class);
        System.out.println(ud);//com.atguigu.ioc.userMod.dao.UserDaoImpl@86be70a
        
        uc.addUser();
    }
}

10.运行结果

UserController
UserServiceImpl
UserDaoImpl
com.atguigu.ioc.userMod.controller.UserController@6f195bc3
com.atguigu.ioc.userMod.service.UserServiceImpl@51e2adc7
com.atguigu.ioc.userMod.dao.UserDaoImpl@1a8a8f7c
添加成功

发表于 分类于 ， ， ，

使用注解配置bean

1.项目目录

2.UserController.java

package com.atguigu.ioc.userMod.controller;

import org.springframework.stereotype.Controller;

@Controller
public class UserController {

    public UserController() {
        System.out.println("UserController");
    }
    
}

3.UserDao.java

package com.atguigu.ioc.userMod.dao;

public interface UserDao {

}

4.UserDaoImpl.java(UserDao接口的实现类)

package com.atguigu.ioc.userMod.dao;

import org.springframework.stereotype.Repository;

@Repository
public class UserDaoImpl implements UserDao{
    public UserDaoImpl(){
        System.out.println("UserDaoImpl");
    }
}

5.UserService.java

package com.atguigu.ioc.userMod.service;

public interface UserService {

}

6.UserServiceImpl.java(UserService接口的实现类)

package com.atguigu.ioc.userMod.service;

import org.springframework.stereotype.Service;

@Service
public class UserServiceImpl implements UserService{

    public UserServiceImpl() {
        System.out.println("UserServiceImpl");
    }

}

7.user.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 http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    
    <!-- 
        <context:component-scan>:扫描组件，对设置的包下面的类进行扫描，会将加上注解的类作为spring的组件进行加载
        组件：指spring中管理的bean
        作为spring的组件进行加载：会自动在spring的配置文件中生成相对应的bean，这些bean的id会以类的首字母小写为值
        
        <context:include-filter>:在设定的包结构下再次通过注解或类型具体包含到某个或某几个类
        注意：在使用包含时，一定要设置use-default-filters="false"，将默认（即扫描包下所有的类）的过滤关闭
        
        <context:exclude-filter>:在设定的包结构下，再次通过注解或类型具体排除某个或某几个类
        注意：在使用排除时，一定要设置use-default-filters="true"，将默认（即扫描包下所有的类）的过滤打开
        
        切记：一个<context:component-scan>中可以出现多个include，也可以同时出现多个exclude，但是两个不能同时出现
     -->
    <context:component-scan base-package="com.atguigu.ioc.userMod" use-default-filters="true">
        <!-- <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/> -->
        <!-- <context:include-filter type="assignable" expression="com.atguigu.ioc.userMod.service.UserServiceImpl"/> -->
        <!-- <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/> -->
        <!-- <context:exclude-filter type="assignable" expression="com.atguigu.ioc.userMod.dao.UserDaoImpl"/> -->
    </context:component-scan>
    
    <!-- <bean id="userController" class="com.atguigu.ioc.userMod.controller.UserController"></bean>
    <bean id="userServiceImpl" class="com.atguigu.ioc.userMod.service.UserServiceImpl"></bean>
    <bean id="userDaoImpl" class="com.atguigu.ioc.userMod.dao.UserDaoImpl"></bean> -->
</beans>

8.Test.java

package com.atguigu.ioc.userMod;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.atguigu.ioc.userMod.controller.UserController;
import com.atguigu.ioc.userMod.dao.UserDao;
import com.atguigu.ioc.userMod.dao.UserDaoImpl;
import com.atguigu.ioc.userMod.service.UserService;
import com.atguigu.ioc.userMod.service.UserServiceImpl;

public class Test {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("user.xml");
        
        UserController uc = ac.getBean("userController", UserController.class);
        System.out.println(uc);//com.atguigu.ioc.userMod.controller.UserController@4b553d26
        
        UserService us = ac.getBean("userServiceImpl", UserServiceImpl.class);
        System.out.println(us);//com.atguigu.ioc.userMod.service.UserServiceImpl@69a3d1d
        
        UserDao ud = ac.getBean("userDaoImpl", UserDaoImpl.class);
        System.out.println(ud);//com.atguigu.ioc.userMod.dao.UserDaoImpl@86be70a
    }
}

发表于 分类于 ， ， ，

自动装配（自动为属性赋值）

1.项目目录

2.Emp.java

package com.atguigu.ioc.auto;

public class Emp {
    private Integer eid;
    private String ename;
    //private Car car;//类型可以写该类以及该类的父类
    private CarExtends car;
    //private Dept dept;//类型可以写该类以及该类的父类
    private DeptI dept;
    public Integer getEid() {
        return eid;
    }
    public void setEid(Integer eid) {
        this.eid = eid;
    }
    public String getEname() {
        return ename;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public CarExtends getCar() {
        return car;
    }
    public void setCar(CarExtends car) {
        this.car = car;
    }
    public DeptI getDept() {
        return dept;
    }
    public void setDept(DeptI dept) {
        this.dept = dept;
    }
    @Override
    public String toString() {
        return "Emp [eid=" + eid + ", ename=" + ename + ", car=" + car + ", dept=" + dept + "]";
    }
    
}

3.CarExtends.java(Car的父类)

package com.atguigu.ioc.auto;

public class CarExtends {

}

4.Car.java

package com.atguigu.ioc.auto;

public class Emp {
    private Integer eid;
    private String ename;
    //private Car car;//类型可以写该类以及该类的父类
    private CarExtends car;
    //private Dept dept;//类型可以写该类以及该类的父类
    private DeptI dept;
    public Integer getEid() {
        return eid;
    }
    public void setEid(Integer eid) {
        this.eid = eid;
    }
    public String getEname() {
        return ename;
    }
    public void setEname(String ename) {
        this.ename = ename;
    }
    public CarExtends getCar() {
        return car;
    }
    public void setCar(CarExtends car) {
        this.car = car;
    }
    public DeptI getDept() {
        return dept;
    }
    public void setDept(DeptI dept) {
        this.dept = dept;
    }
    @Override
    public String toString() {
        return "Emp [eid=" + eid + ", ename=" + ename + ", car=" + car + ", dept=" + dept + "]";
    }
    
}

5.DeptI.java（接口）

package com.atguigu.ioc.auto;

public interface DeptI {

}

6.Dept.java（DeptI接口的实现类）

package com.atguigu.ioc.auto;

public class Dept implements DeptI{
    private Integer did;
    private String dname;
    public Integer getDid() {
        return did;
    }
    public void setDid(Integer did) {
        this.did = did;
    }
    public String getDname() {
        return dname;
    }
    public void setDname(String dname) {
        this.dname = dname;
    }
}

7.auto.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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!--
        autowire:根据某种策略自动未非字面量属性赋值
        autowire="byName|byType"
        byName:通过属性名和spring容器中bean的id进行比较，若一致则可直接赋值
        byType:通过spring容器中bean的类型，为兼容性（子类对象为父类赋值，实现类为接口赋值）的属性赋值 
                在使用byType的过程中，要求spring容器中只能有一个能为属性赋值的bean
        
        选用建议：当设置autowire属性，会最作用于该bean中所有的非字面量属性，因此谁都不用
     -->
    
    <bean id="emp" class="com.atguigu.ioc.auto.Emp" autowire="byName"><!-- byName/byType -->
        <property name="eid" value="1001"></property>
        <property name="ename" value="张三"></property>
        <!-- <property name="car" ref="car"></property>
        <property name="dept" ref="dept"></property> -->
    </bean>
    
    <bean id="car" class="com.atguigu.ioc.auto.Car">
        <property name="cid" value="666666"></property>
        <property name="cname" value="霸道"></property>
    </bean>
    
    <bean id="dept" class="com.atguigu.ioc.auto.Dept">
        <property name="did" value="1111"></property>
        <property name="dname" value="开发部"></property>
    </bean>
</beans>

8.Test.java

package com.atguigu.ioc.auto;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ApplicationContext ac = new ClassPathXmlApplicationContext("auto.xml");
        
        Emp bean = ac.getBean("emp", Emp.class);
        
        System.out.println(bean);
    }
}

9.运行结果

Emp [eid=1001, ename=张三, car=com.atguigu.ioc.auto.Car@31ef45e3, dept=com.atguigu.ioc.auto.Dept@598067a5]

发表于 更新于 分类于 ， ， ，

引用外部属性文件

1.项目目录

2.导入druid-1.1.9.jar、mysql-connector-java-5.1.7-bin.jar

3.db.properties

# k = v
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=root
jdbc.password=123456

4.datasource.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 http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    
    <!-- 直接配置 -->
    <!-- <bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
        <property name="url" value="jdbc:mysql://localhost:3306/test"></property>
        <property name="username" value="root"></property>
        <property name="password" value="123456"></property>
    </bean> -->
    
    <!-- 加载资源文件（引用外部资源文件） -->
    <!-- <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="db.properties"></property>
    </bean>
    <bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean> -->
    
    <!-- 使用context标签加载资源文件（引用外部属性文件） -->
    <context:property-placeholder location="db.properties"/>
    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="db.properties"></property>
    </bean>
    <bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"></property>
        <property name="url" value="${jdbc.url}"></property>
        <property name="username" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean> 
</beans>

5.Test.java

package com.atguigu.ioc.datasource;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.alibaba.druid.pool.DruidDataSource;

public class Test {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        ApplicationContext ac = new ClassPathXmlApplicationContext("datasource.xml");
        
        DruidDataSource bean = ac.getBean("datasource", DruidDataSource.class);
        
        System.out.println(bean);
        
        //System.out.println(bean.getConnection());
    }

}

发表于 更新于 分类于 ， ， ，

bean的生命周期、bean的后置处理器

1.项目目录

2.bean的生命周期（******）
① 通过构造器或工厂方法创建bean实例
② 为bean的属性设置值和对其他bean的引用
③ 调用bean的初始化方法
④ bean可以使用了
⑤ 当容器关闭时，调用bean的销毁方法

3.Person.java

package com.atguigu.ioc.life;

public class Person {
    private Integer id;
    private String sex;
    private String name;
    
    public Integer getId() {
        return id;
    }
    
    public void setId(Integer id) {
        System.out.println("Two:依赖注入");
        this.id = id;
    }
    
    public String getSex() {
        return sex;
    }
    
    public void setSex(String sex) {
        this.sex = sex;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public Person() {
        System.out.println("One:创建对象");
    }
    
    public void init(){
        System.out.println("Three:初始化");
    }
    
    

    @Override
    public String toString() {
        return "Four: Person [id=" + id + ", sex=" + sex + ", name=" + name + "]";
    }

    public void destroy(){
        System.out.println("Five:销毁");
    }
}

4.AfterHandler.java(后置处理器)

package com.atguigu.ioc.life;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class AfterHandler implements BeanPostProcessor{

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // TODO Auto-generated method stub
        return bean;
    }

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        Person person = (Person)bean;
        if(person.getSex().equals("男")){
            person.setName("张无忌");
        }else{
            person.setName("赵敏");
        }
        return person;
    }
 
}

5.life.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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!-- 测试bean的生命周期 -->
    <bean id="person" class="com.atguigu.ioc.life.Person" init-method="init" destroy-method="destroy">
        <property name="id" value="1001"></property>
        <property name="sex" value="男"></property>
    </bean>
    
    <!-- 测试后置处理器 -->
    <bean class="com.atguigu.ioc.life.AfterHandler"></bean>
</beans>

6.Test.java

package com.atguigu.ioc.life;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("life.xml");
        
        Person person = ac.getBean("person", Person.class);
        System.out.println(person);
        
        ac.close();
    }
}

7.运行结果

One:创建对象
Two:依赖注入
Three:初始化
Four: Person [id=1001, sex=男, name=张无忌]
二月 15, 2022 4:34:28 下午 org.springframework.context.support.ClassPathXmlApplicationContext doClose
信息: Closing org.springframework.context.support.ClassPathXmlApplicationContext@2dda6444: startup date [Tue Feb 15 16:34:27 CST 2022]; root of context hierarchy
Five:销毁