Hibernate框架--对象的状态，缓存， 映射
回顾Hibernate第二天：
1. 一对多与多对一
2. 多对多
3. inverse/cascade
4. 关联关系的维护
一对多:
<set name="映射的集合属性" table="(可选)集合属性对应的外键表">
<key column="外键表的，外键字段" />
<one-to-many class="集合元素的类型" />
</set>
多对一：
<many-to-one name="对象属性" class="对象类型" column="外键字段字段" />
多对多
<set name="" table="">
<key column="" />
<many-to-many column="" class="">
</set>
目标：
第1部分: 对象的状态：
第2部分：缓存
1) 一级缓存
2) 相关知识
----懒加载---
第3部分：映射
一对一映射
组件映射
继承映射
一、对象的状态
举例： User user = new User();
Hibernate中对象的状态： 临时/瞬时状态、持久化状态、游离状态。
1. 临时状态
特点：
直接new出来的对象;
不处于session的管理;
数据库中没有对象的记录;
1. 持久化状态
当调用session的save/saveOrUpdate/get/load/list等方法的时候，对象就是持久化状态。
处于持久化状态的对象，当对对象属性进行更改的时候，会反映到数据库中!
特点：
处于session的管理;
数据库中有对应的记录;
3. 游离状态
特点：
不处于session的管理；
数据库中有对应的记录
Session关闭后，对象的状态；
对象状态的转换
public class User {
private int userId;
private String userName;
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
@Override
public String toString() {
return "User [userId=" + userId + ", userName=" + userName + "]";
}
}
<hibernate-mapping package="cn.itcast.a_status">
<class name="User" table="t_user">
<id name="userId" column="id">
<generator class="native"></generator>
</id>
<property name="userName"></property>
</class>
</hibernate-mapping>
public class App1_status {
private static SessionFactory sf;
static {
sf = new Configuration()
.configure()
.addClass(User.class) // 测试时候使用
.buildSessionFactory();
}
//1. 对象状态的转换
@Test
public void testSaveSet() throws Exception {
Session session = sf.openSession();
session.beginTransaction();
// 创建对象 【临时状态】
// User user = new User();
// user.setUserName("Jack22222");
// 保存 【持久化状态】
// session.save(user);
// user.setUserName("Jack333333"); // 会反映到数据库
// 查询
User user = (User) session.);
user.setUserName("Tomcat");// hibernate会自动与数据库匹配（一级缓存），如果一样就更新数据库
session.getTransaction().commit();
session.close();
user.setUserName("Jack444444444");
// 打印 【游离状态】
System.out.println(user.getUserId());
System.out.println(user.getUserName());
}
@Test
public void bak() throws Exception {
Session session = sf.openSession();
session.beginTransaction();
session.getTransaction().commit();
session.close();
}
}
二、一级缓存
为什么要用缓存？
目的：减少对数据库的访问次数！从而提升hibernate的执行效率！
Hibernate中缓存分类：
一级缓存
二级缓存
ü 概念
1）Hibenate中一级缓存，也叫做session的缓存，它可以在session范围内减少数据库的访问次数！ 只在session范围有效！ Session关闭，一级缓存失效！
2）当调用session的save/saveOrUpdate/get/load/list/iterator方法的时候，都会把对象放入session的缓存中。
3）Session的缓存由hibernate维护， 用户不能操作缓存内容； 如果想操作缓存内容，必须通过hibernate提供的evit/clear方法操作。
特点：
只在(当前)session范围有效，作用时间短，效果不是特别明显！
在短时间内多次操作数据库，效果比较明显！
ü 缓存相关几个方法的作用
session.flush(); 让一级缓存与数据库同步
session.evict(arg0); 清空一级缓存中指定的对象
session.clear(); 清空一级缓存中缓存的所有对象
在什么情况用上面方法？
批量操作使用使用：
Session.flush(); // 先与数据库同步
Session.clear(); // 再清空一级缓存内容
ü 面试题1： 不同的session是否会共享缓存数据? 不会。
User1 u1 = Session1.get(User.class,1); 把u1对象放入session1的缓存
Session2.update(u1); 把u1放入session2的缓存
U1.setName(‘new Name’);
如果生成2条update sql， 说明不同的session使用不同的缓存区，不能共享。
public class App2_cache {
private static SessionFactory sf;
static {
sf = new Configuration()
.configure()
.addClass(User.class) // 测试时候使用
.buildSessionFactory();
}
@Test
public void testCache() throws Exception {
Session session = sf.openSession();
session.beginTransaction();
User user = null;
// 查询
user = (User) session.);// 先检查缓存中是否有数据，如果有不查询数据库，直接从缓存中获取
user = (User) session.);// 这一句就不再向数据库发送查询命令了，减少了与数据库的交互。
session.getTransaction().commit();
session.close();
}
@Test
public void flush() throws Exception {
Session session = sf.openSession();
session.beginTransaction();
User user = null;
user = (User) session.);
user.setUserName("Jack");
// 缓存数据与数据库同步
session.flush();
user.setUserName("Jack_new");
session.getTransaction().commit(); // session.flush();
session.close();
}
@Test
public void clear() throws Exception {
Session session = sf.openSession();
session.beginTransaction();
User user = null;
// 查询
user = (User) session.);
// 清空缓存内容
// session.clear(); // 清空所有
session.evict(user);// 清除指定
user = (User) session.);
session.getTransaction().commit(); // session.flush();
session.close();
}
@Test
public void sessionTest() throws Exception {
Session session1 = sf.openSession();
session1.beginTransaction();
Session session2 = sf.openSession();
session2.beginTransaction();
// user放入session1的缓存区
User user = (User) session1.);
// user放入session2的缓存区
session2.update(user);
// 修改对象
user.setUserName("New Name"); // 2条update
session1.getTransaction().commit(); // session1.flush();
session1.close();
session2.getTransaction().commit(); // session2.flush();
session2.close();
}
}
面试题2： list与iterator查询的区别？
list() 一次把所有的记录都查询出来，
会放入缓存，但不会从缓存中获取数据
Iterator N+1查询； N表示所有的记录总数
即会先发送一条语句查询所有记录的主键（1），再根据每一个主键再去数据库查询（N）！
会放入缓存，也会从缓存中取数据！
public class App3_list_iterator {
private static SessionFactory sf;
static {
sf = new Configuration()
.configure()
.addClass(User.class) // 测试时候使用
.buildSessionFactory();
}
/**
* list与iterator区别
* 1. list 方法
* 2. iterator 方法
* 3. 缓存
* @throws Exception
*/
//1. list 方法
@Test
public void list() throws Exception {
Session session = sf.openSession();
session.beginTransaction();
// HQL查询 这句不会向数据库发送sql语句查询
Query q = session.createQuery("from User ");
// list()方法 执行q.list()才会会向数据库发送查询的sql语句
List<User> list = q.list();
; i<list.size(); i++){
System.out.println(list.get(i));
}
session.getTransaction().commit();
session.close();
}
//2. iterator 方法
@Test
public void iterator() throws Exception {
Session session = sf.openSession();
session.beginTransaction();
// HQL查询
Query q = session.createQuery("from User ");
// iterator()方法
Iterator<User> it = q.iterate();
while(it.hasNext()){
// 得到当前迭代的每一个对象
User user = it.next();
System.out.println(user);
}
session.getTransaction().commit();
session.close();
}
//3. 缓存
@Test
public void cache() throws Exception {
Session session = sf.openSession();
session.beginTransaction();
/**************执行2次list*****************
Query q = session.createQuery("from User");
List<User> list = q.list(); // 【会把list查询结果放入缓存】
for (int i=0; i<list.size(); i++){
System.out.println(list.get(i));
}
System.out.println("=========list===========");
list = q.list(); // 【不会从上面的缓存中去取list，而是再向数据库发送查询语句】
for (int i=0; i<list.size(); i++){
System.out.println(list.get(i));
}
上面总共会向数据库发送两次查询语句。
/**************执行2次iteator******************/
Query q = session.createQuery("from User ");
Iterator<User> it = q.iterate(); // 【查询结果会放入缓存】
while(it.hasNext()){
User user = it.next();
System.out.println(user);
}
System.out.println("==========iterate===========");
it = q.iterate(); // 【这里不再向数据库发送查询语句了，而是直接从上面的缓存中取】
while(it.hasNext()){
User user = it.next();
System.out.println(user);
}
session.getTransaction().commit();
session.close();
}
上面也是向数据库发送两条sql查询语句，一个是查询总记录数，一个是第一次查询
// 测试list方法会放入缓存
@Test
public void list_iterator() throws Exception {
Session session = sf.openSession();
session.beginTransaction();
// 得到Query接口的引用
Query q = session.createQuery("from User ");
// 先list 【会放入缓存，但不会从缓存中获取数据】
List<User> list = q.list();
; i<list.size(); i++){
System.out.println(list.get(i));
}
// 再iteraotr (会从缓存中取)
Iterator<User> it = q.iterate();
while(it.hasNext()){
User user = it.next();
System.out.println(user);
}
session.getTransaction().commit();
session.close();
}
}
三、懒加载
面试题3： get、load方法区别？
get: 及时加载，只要调用get方法立刻向数据库查询
load:默认使用懒加载，当用到数据的时候才向数据库查询。
懒加载：(lazy) 概念：当用到数据的时候才向数据库查询，这就是hibernate的懒加载特性。
目的：提供程序执行效率！
lazy 值:在配置文件中设置(Dep.hbm.xml)
true 使用懒加载
false 关闭懒加载
extra (在集合数据懒加载时候提升效率)，也属于懒加载，可以理解为是一种比较高级的懒加载
在真正使用数据的时候才向数据库发送查询的sql；
如果调用集合的size()/isEmpty()方法，只是统计，不真正查询数据！
懒加载异常
Session关闭后，不能使用懒加载数据！
如果session关闭后，使用懒加载数据报错：
org.hibernate.LazyInitializationException: could not initialize proxy - no Session
如何解决session关闭后不能使用懒加载数据的问题？
// 方式1： 先使用一下数据
//dept.getDeptName();
// 方式2：强迫代理对象初始化
Hibernate.initialize(dept);
// 方式3：关闭懒加载
设置lazy=false;
// 方式4： 在使用数据之后，再关闭session！
public class App {
private static SessionFactory sf;
static {
sf = new Configuration()
.configure()
.addClass(Dept.class)
.addClass(Employee.class) // 测试时候使用
.buildSessionFactory();
}
//1. 主键查询，及区别
@Test
public void get_load() {
Session session = sf.openSession();
session.beginTransaction();
Dept dept = new Dept();
// get： 及时查询，即使后面不用该查询结果，也会去数据库查询
dept = (Dept) session.get(Dept.class, 9);
System.out.println(dept.getDeptName());
// load，默认懒加载， 及在使用数据的时候，才向数据库发送查询的sql语句！
dept = (Dept)session.load(Dept.);
// 方式1： 先使用一下数据，会去查询数据库，这样就不会报错了。
//dept.getDeptName();
// 方式2：强迫代理对象初始化
Hibernate.initialize(dept);
// 方式3：关闭懒加载
session.getTransaction().commit();
session.close();
// session关闭后在这里使用数据而不报错的四种解决方式。
System.out.println(dept.getDeptName());
}
//1. 主键查询，及区别
@Test
public void set() {
Session session = sf.openSession();
session.beginTransaction();
Dept dept = (Dept) session.);
System.out.println(dept.getDeptName());
System.out.println("------");
System.out.println(dept.getEmps().isEmpty()); // SQL
session.getTransaction().commit();
session.close();
}
}
四、一对一映射（两种映射写法，基于外键，基于主键的映射）
需求: 用户与身份证信息
一条用户记录对应一条身份证信息！ 一对一的关系！
设计数据库：
JavaBean：
映射：
基于外键的映射：把当前表的主键作为其他表的外键
// 用户
public class User {
private int userId;
private String userName;
// 用户与身份证信息， 一对一关系
private IdCard idCard;
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.itcast.c_one2one">
<class name="User" table="t_user">
<id name="userId">
<generator class="native"></generator>
</id>
<property name="userName" length="20"></property>
<!--
一对一映射： 没有外键方
-->
<one-to-one name="idCard" class="IdCard"></one-to-one>
</class>
</hibernate-mapping>
// 身份证
public class IdCard {
// 身份证号(主键)
private String cardNum;// 对象唯一标识(Object Identified, OID)
private String place; // 身份证地址
// 身份证与用户，一对一的关系
private User user;
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.itcast.c_one2one">
<class name="IdCard" table="t_IdCard">
<id name="cardNum">
<generator class="assigned"></generator>//表示手动指定主键的值
</id>
<property name="place" length="20"></property>
<!--
一对一映射，有外键方
unique="true" 给外键字段添加唯一约束
-->
把一个对象映射成一个外键字段，要用many-to-one。在加上一个唯一约束。这就变成了one-to-one
<many-to-one name="user" unique="true" column="user_id" class="User" cascade="save-update"></many-to-one>
</class>
</hibernate-mapping>
public class App {
private static SessionFactory sf;
static {
sf = new Configuration()
.configure()
.addClass(IdCard.class)
.addClass(User.class) // 测试时候使用
.buildSessionFactory();
}
@Test
public void getSave() {
Session session = sf.openSession();
session.beginTransaction();
// 用户
User user = new User();
user.setUserName("Jack");
// 身份证
IdCard idCard = new IdCard();
idCard.setCardNum("441202XXX");
idCard.setPlace("广州XXX");
// 关系
idCard.setUser(user);
// ----保存----
session.save(idCard);
session.getTransaction().commit();
session.close();
}
}
基于主键的映射：把当前表的主键作为其他表的主键
user类即映射不变，只要更改idcard及映射即可。
// 身份证
public class IdCard {
private int user_id;
// 身份证号
private String cardNum;
private String place; // 身份证地址
// 身份证与用户，一对一的关系
private User user;
<hibernate-mapping package="cn.itcast.c_one2one2">
<class name="IdCard" table="t_IdCard">
<id name="user_id">
<!--
id 节点指定的是主键映射, 即user_id是主键
主键生成方式： foreign 即把别的表的主键作为当前表的主键；
property (关键字不能修改)指定引用的对象 对象的全名 cn..User、 对象映射 cn.User.hbm.xml、 table(id)
-->
<generator class="foreign">
<param name="property">user</param>
</generator>
</id>
<property name="cardNum" length="20"></property>
<property name="place" length="20"></property>
<!--
一对一映射，有外键方
（基于主键的映射）
constrained="true" 指定在主键上添加外键约束
-->
<one-to-one name="user" class="User" constrained="true" cascade="save-update"></one-to-one>
</class>
</hibernate-mapping>
五、组件映射与继承映射
类的关系
组合关系
一个类中包含了另外一个类。这2个类中就是组合关系。
需求： 汽车与车轮
继承关系
一个类继承另外一个类。这2个类中就是继承关系。
需求：动物
组件映射
类组合关系的映射，也叫做组件映射！
注意：组件类和被包含的组件类，共同映射到一张表！
需求： 汽车与车轮
数据库:T_car
主键 汽车名称 轮子大小 个数
public class Car {
private int id;
private String name;
// 车轮
private Wheel wheel;
}
// 车轮
public class Wheel {
private int count;
private int size;
}
Car.hbm.xml
<hibernate-mapping package="cn.itcast.d_component">
<class name="Car" table="t_car">
<id name="id">
<generator class="native"></generator>
</id>
<property name="name" length="20"></property>
<!-- 组件映射 -->
<component name="wheel">
<property name="size"></property>
<property name="count"></property>
</component>
</class>
</hibernate-mapping>
public class App {
private static SessionFactory sf;
static {
sf = new Configuration()
.configure()
.addClass(Car.class)
.buildSessionFactory();
}
@Test
public void getSave() {
Session session = sf.openSession();
session.beginTransaction();
// 轮子
Wheel wheel = new Wheel();
wheel.setSize();
wheel.setCount();
// 汽车
Car car = new Car();
car.setName("BMW");
car.setWheel(wheel);
// 保存
session.save(car);
session.getTransaction().commit();
session.close();
}
}
继承映射
需求：动物
猫
猴子
简单继承映射
// 动物类
public abstract class Animal {
private int id;
private String name;
public class Cat extends Animal{
// 抓老鼠
private String catchMouse;
public String getCatchMouse() {
return catchMouse;
}
public void setCatchMouse(String catchMouse) {
this.catchMouse = catchMouse;
}
}
Cat.hbm.xml
<!--
简单继承
-->
<hibernate-mapping package="cn.itcast.e_extends1">
<class name="Cat" table="t_Cat">
<!-- 简单继承映射： 父类属性直接写 -->
<id name="id">
<generator class="native"></generator>
</id>
<property name="name"></property>
<property name="catchMouse"></property>
</class>
</hibernate-mapping>
public class App {
private static SessionFactory sf;
static {
sf = new Configuration()
.configure()
.addClass(Cat.class)
.buildSessionFactory();
}
@Test
public void getSave() {
Session session = sf.openSession();
session.beginTransaction();
// 保存
// Cat cat = new Cat();
// cat.setName("大花猫");
// cat.setCatchMouse("抓小老鼠");
// session.save(cat);
// 获取时候注意：当写hql查询的使用，通过父类查询必须写上类的全名
Query q = session.createQuery("from cn.itcast.e_extends1.Animal");
List<Animal> list = q.list();
System.out.println(list);
session.getTransaction().commit();
session.close();
}
}
总结：简单继承映射，有多少个子类，写多少个映射文件！如果子类过多，配置文件太多了。
继承映射
需求：猫、猴子、动物。
所有子类映射到一张表 (1张表)
什么情况用？
子类教多，且子类较为简单，即只有个别属性！
好处：因为使用一个映射文件， 减少了映射文件的个数。
缺点：（不符合数据库设计原则）
一个映射文件： Animal.hbm.xml
(如何区分是哪个子类的信息？)
数据库:
T_animal （要存储所有的子类信息） “鉴别器”
Id name catchMouse eatBanana type_(区别是哪个子类)
1 大马猴 NULL 吃10个香蕉 猴子
2 大花猫 不抓老鼠 NULL 猫
总结：
写法较为简单：所有子类用一个映射文件，且映射到一张表！
但数据库设计不合理!
（不推荐用。）
每个类映射一张表(3张表)
数据库
T_anmal （存储父类信息）
1 大花猫
T_cat （引用父类的主键）
1 抓小老鼠
T_monkey（引用父类的主键）
|
Javabean设计一样，映射实现不同： |
|
<!-- 继承映射， 每个类对应一张表(父类也对应表) --> <hibernate-mapping package="cn.itcast.e_extends3"> <class name="Animal" table="t_animal"> <id name="id"> <generator class="native"></generator> </id> <property name="name"></property> <!-- 子类：猫 t_cat key 指定_cat表的外键字段 --> <joined-subclass name="Cat" table="t_cat"> <key column="t_animal_id"></key> <property name="catchMouse"></property> </joined-subclass> <!-- 子类：猴子 t_monkey --> <joined-subclass name="Monkey" table="t_monkey"> <key column="t_animal_id"></key> <property name="eatBanana"></property> </joined-subclass> </class> </hibernate-mapping> |
总结：
一个映射文件，存储所有的子类； 子类父类都对应表；
缺点：表结构比较负责，插入一条子类信息，需要用2条sql： 往父类插入、往子类插入！
(推荐)每个子类映射一张表， 父类不对应表(2张表)
数据库：
T_cat
Id name catchMounse
T_monkey
Id name eatBanana
|
<union-subclass name="Cat" table="t_cat"> <property name="catchMouse"></property> </union-subclass> |
|
注意：主键不能是自增长！ |
总结：
所有的子类都写到一个映射文件；
父类不对应表； 每个子类对应一张表
Hibernate中映射：
多对一
一对多
多对多
一对一 （多对一的特殊应用）
组件
继承
Hibernate框架--对象的状态，缓存， 映射的更多相关文章
- Hibernate框架（四）缓存策略+lazy
Hibernate作为和数据库数据打交道的框架,自然会设计到操作数据的效率问题,而对于一些频繁操作的数据,缓存策略就是提高其性能一种重要手段,而Hibernate框架是支持缓存的,而且支持一级和二级两 ...
- Hibernate对象的状态和映射
一. Hibernate对象的状态 实体对象的三种状态: 1) 暂态(瞬时态)(Transient)---实体在内存中的自由存在,它与数据库的记录无关. po在DB中无记录(无副本),po和sessi ...
- hibernate框架学习之二级缓存
缓存的意义 l应用程序中使用的数据均保存在永久性存储介质之上,当应用程序需要使用数据时,从永久介质上进行获取.缓存是介于应用程序与永久性存储介质之间的一块数据存储区域.利用缓存,应用程序可以将使用的数 ...
- hibernate框架学习之一级缓存
l缓存是存储数据的临时空间,减少从数据库中查询数据的次数 lHibernate中提供有两种缓存机制 •一级缓存(Hibernate自身携带) •二级缓存(使用外部技术) lHibernate的一级缓存 ...
- Hibernate持久化对象的状态
1. 站在持久化的角度 , Hibernate 把对象分为 4 种状态 : 持久化状态, 暂时状态, 游离状态(脱管状态) , 删除状态.Session 的特定方法能使对象从一个状态转换到还有一个状态 ...
- （转）Hibernate框架基础——一对多关联关系映射
http://blog.csdn.net/yerenyuan_pku/article/details/52746413 上一篇文章Hibernate框架基础——映射集合属性详细讲解的是值类型的集合(即 ...
- Hibernate 持久化对象和一级缓存
关于如何手动创建Hibernate,Hibernate初了解已经介绍了,接下来了解持久化对象和一级缓存. Hibernate的持久化类有三种状态: 1.Transient瞬时态:持久化对象没有唯一标识 ...
- 在Hibernate框架中详谈一级缓存
在学习Hibernate的过程中我们肯定会碰上一个名词---缓存,一直都听说缓存机制是Hibernate中的一个难点,它分为好几种,有一级缓存,二级缓存和查询缓存 今天呢,我就跟大家分享分享我所理解的 ...
- Hibernate PO对象的状态
Hibernate的PO对象有三种状态:临时状态(又称临时态).持久状态(又称为持久态)和脱管状态(又称为脱管态.游离态).处理持久态的对象也称为PO,临时对象和脱管对象也称为VO. 1.临时态: 简 ...
随机推荐
- git 客户端提交
01 按照git到本地 02 按照小乌龟操作面板, 03 (git 和小乌龟)自动加载到右键快捷方式
- 《Intel汇编第5版》 数组求和
一.LOOP指令 二.间接寻址 三.汇编数组求和 INCLUDE Irvine32.inc includelib Irvine32.lib includelib kernel32.lib includ ...
- HDU 1040 As Easy As A+B(排序)
As Easy As A+B Problem Description These days, I am thinking about a question, how can I get a probl ...
- ResultSet.TYPE_SCROLL_SENSITIVE问题（完全摘自他人）
摘自CSDN博客 我们先来做一个例子,在例子中我用的是mysql-essential-5.1.30-win32版. 来跟我做以下几个命令: mysql> create database axma ...
- iOS 打包上传AppStore相关(2)-Xcode相应配置
上一篇描述了如何在AppleDeveloper创建Certificates.App IDs和Provisioning Profiles的过程.本篇将详细描述在Xcode部分我们需要做的配置. 1.配置 ...
- C 语言学习准备
摘要:用 C#语言学习了一些数据结构,突然想学习 C 语言,为了学习C,本文准备好资料. C 语言学习准备 作者:乌龙哈里 时间:2015-11-17 平台:Window7 64bit,Visual ...
- Linux nfs+autofs 环境搭建
两台服务器环境为centos 6.6 1.安装配置nfs 安装portmap 和 nfs [root@node0 ~]# yum install portmap [root@node0 ~]# yu ...
- JAVA中方法的定义与使用（课堂学习归纳）
组合数,百度词条是这样解释的:从m个不同元素中取出n(n≤m)个元素的所有组合的个数,叫做从m个不同元素中取出n个元素的组合数(Combination) 对于计算组合数,需要一定的工作量,计算机可以很 ...
- hdu1010
#include <stdio.h>#include <string.h>#include <math.h> int n,m,t;char map[10][10]; ...
- Quickly Start Listener scripts
#!/usr/bin/python # # StartListener.py # Simple python script to start a Meterpreter Listener # Auto ...