zhihchen
- 浏览: 75155 次
-
文章分类
最新评论
1、 属性的映射文件
<!—name是实体类的全路径 ，table重命名 <class name="com.creasoft.entity.Products" table="product"> <id name="pid" column="p_id" type="long"> <generator class="increment"></generator> </id> <!—unique 定义的是否重复 <property name="productName" column="product_name" type="string" not-null="true" unique="true" length="20"> </property> <property name="factory" type="string"></property> <property name="price" type="double"></property> </class>
2、配置文件
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd" > <hibernate-configuration> <session-factory> <property name="connection.url"> jdbc:mysql://localhost:3306/hibernate </property> <property name="connection.driver_class"> com.mysql.jdbc.Driver </property> <property name="connection.username">root</property> <property name="connection.password">123456</property> <!-方言- <property name="dialect"> org.hibernate.dialect.MySQLDialect </property> <!-在控制台显示sql语句- <property name="show_sql">true</property> <!-sql语句格式化- <property name="format_sql">true</property> <!-建表的方式- <prrperty name=” hbm2ddl.auto”>update</property> <!-连接映射文件- <mapping resource="com/creasoft/entity2/Customer.hbm.xml" /> <mapping resource="com/creasoft/entity2/VipCard.hbm.xml" /> </session-factory> </hibernate-configuration>
3、hibernate的工具类
package com.creasoft.util;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class Hibernateutil {
private static SessionFactory sessionFactory ;
//私有的构造方法，防止用户直接new
private Hibernateutil(){
}
//获取sessionfactory
public static SessionFactory getsessionFactory(){
if(sessionFactory == null || sessionFactory.isClosed()){
sessionFactory = new Configuration().configure().buildSessionFactory();
}
return sessionFactory;
}
//打开一个session
public static Session getSession(){
return getsessionFactory().openSession();
}
//关闭session
public static void close(){
getSession().close();
}
}
4、创建表
package com.creasoft.util;
import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
public class CreateTable {
public static void main(String[] args) {
//读取配置文件
Configuration cfg = new Configuration().configure();
System.out.println("a");
SchemaExport schemaExport = new SchemaExport(cfg);
System.out.println("b");
schemaExport.create(true, true);
System.out.println("c");
}
}
5、一对多单向关联
实例：顾客—订单
1）实体类
a、一
package com.creasoft.entity;
import java.util.HashSet;
import java.util.Set;
public class Customer {
private long cid;
private String customerName;
private String gender;
//构造方法
public Customer(String customerName, String gender) {
super();
this.customerName = customerName;
this.gender = gender;
}
public Customer(long cid, String customerName, String gender,
Set<CustomerOrder> sustomerOrders) {
super();
this.cid = cid;
this.customerName = customerName;
this.gender = gender;
this.sustomerOrders = sustomerOrders;
}
public Customer() {
super();
}
//标准的set、get方法
public long getCid() {
return cid;
}
public void setCid(long cid) {
this.cid = cid;
}
public String getCustomerName() {
return customerName;
}
public void setCustomerName(String customerName) {
this.customerName = customerName;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
b、多实体类：把一的所有的属性都要包含进来
package com.creasoft.entity;
public class CustomerOrder {
private long uid;
private String product;
private Customer customer;
public CustomerOrder(String product, Customer customer) {
super();
this.product = product;
this.customer = customer;
}
public CustomerOrder() {
super();
}
public long getUid() {
return uid;
}
public void setUid(long uid) {
this.uid = uid;
}
public String getProduct() {
return product;
}
public void setProduct(String product) {
this.product = product;
}
public Customer getCustomer() {
return customer;
}
public void setCustomer(Customer customer) {
this.customer = customer;
}
}
2)映射文件
A、一的映射文件：一般的映射文件一样
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.creasoft.entity.Customer" table="customer">
<id name="cid" type="long">
<generator class="identity"></generator>
</id>
<property name="customerName" type="string" not-null="true"/>
<property name="gender" type="string" length="2"></property>
</class>
</hibernate-mapping>
B、多：自己的基本属性和一般的映射文件一样，复杂属性放到<many-to-one>的标签，其他的都一样
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.creasoft.entity.CustomerOrder" table="customer_order">
<id name="uid" type="long">
<generator class="identity"></generator>
</id>
<property name="product" type="string" not-null="true"/>
<many-to-one name="customer"
class="com.creasoft.entity.Customer"
not-null="true"
column="customer_id"
cascade="delete"
></many-to-one>
</class>
</hibernate-mapping>
1.1 3)插入一条数据:先要保存一的那一边的实体类
Session session = Hibernateutil.getSession();
//开始事务
Transaction tsaction = session.beginTransaction();
Customer cs = new Customer("chen","m");
CustomerOrder so = new CustomerOrder("手机",cs);
session.save(cs);
session.save(so);
//提交事务
tsaction.commit();
//关闭session
session.close();
6、一对多的双向关联
1）实体类
A、一：与单向关联相比多了一个集合
package com.creasoft.entity;
import java.util.HashSet;
import java.util.Set;
public class Customer {
private long cid;
private String customerName;
private String gender;
private Set<CustomerOrder> sustomerOrders = new HashSet<CustomerOrder>();
public Customer(String customerName, String gender) {
super();
this.customerName = customerName;
this.gender = gender;
}
public Customer(long cid, String customerName, String gender,
Set<CustomerOrder> sustomerOrders) {
super();
this.cid = cid;
this.customerName = customerName;
this.gender = gender;
this.sustomerOrders = sustomerOrders;
}
public Customer() {
super();
}
public long getCid() {
return cid;
}
public void setCid(long cid) {
this.cid = cid;
}
public String getCustomerName() {
return customerName;
}
public void setCustomerName(String customerName) {
this.customerName = customerName;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public Set<CustomerOrder> getSustomerOrders() {
return sustomerOrders;
}
public void setSustomerOrders(Set<CustomerOrder> sustomerOrders) {
this.sustomerOrders = sustomerOrders;
}
}
B、多的实体类不变
package com.creasoft.entity;
public class CustomerOrder {
private long uid;
private String product;
private Customer customer;
public CustomerOrder(String product, Customer customer) {
super();
this.product = product;
this.customer = customer;
}
public CustomerOrder() {
super();
}
public long getUid() {
return uid;
}
public void setUid(long uid) {
this.uid = uid;
}
public String getProduct() {
return product;
}
public void setProduct(String product) {
this.product = product;
}
public Customer getCustomer() {
return customer;
}
public void setCustomer(Customer customer) {
this.customer = customer;
}
}
1.2 2）映射文件
1.2.1 A、一：把集合放入set标签中，set标签中还增了一个<one-to-many>标签
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.creasoft.entity.Customer" table="customer">
<id name="cid" type="long">
<generator class="identity"></generator>
</id>
<property name="customerName" type="string" not-null="true"/>
<property name="gender" type="string" length="2"></property>
<!-- 双向的关联 ,key column的值一定要与CustomerOder.hbm.xml中的外键的值要一样 。name放的是集合属性
inverse="true",表示多的一方不必要在等一这边操作完，这的效率要高-->
<set name="sustomerOrders" inverse="true">
<key column="customer_id"></key>
<one-to-many class="com.creasoft.entity.CustomerOrder"/>
</set>
</class>
</hibernate-mapping>
1.2.2 B、多：与单向的一样
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.creasoft.entity.CustomerOrder" table="customer_order">
<id name="uid" type="long">
<generator class="identity"></generator>
</id>
<property name="product" type="string" not-null="true"/>
<many-to-one name="customer"
class="com.creasoft.entity.Customer"
not-null="true"
column="customer_id"
cascade="delete"
></many-to-one>
</class>
</hibernate-mapping>
1.3 3)插入一条数据:先要保存一的那一边的实体类
Session session = Hibernateutil.getSession();
//开始事务
Transaction tsaction = session.beginTransaction();
Customer cs = new Customer();
cs.setCustomerName("chen");
cs.setGender("m");
CustomerOrder co = new CustomerOrder("sdf",cs);
CustomerOrder ct = new CustomerOrder("d",cs);
cs.getSustomerOrders().add(co);
cs.getSustomerOrders().add(ct);
session.save(cs);
session.save(co);
session.save(ct);
//提交事务
tsaction.commit();
//关闭session
session.close();
7、一对一
1）实体类
A
package com.creasoft.entity2;
public class Customer {
private long cid;
private String customerName;
private VipCard vipcard;
/*
* 构造方法
*/
public Customer() {
super();
}
public Customer(String customerName, VipCard vipcard) {
super();
this.customerName = customerName;
this.vipcard = vipcard;
}
/*
* 标准的get、set方法
*/
public long getCid() {
return cid;
}
public void setCid(long cid) {
this.cid = cid;
}
public String getCustomerName() {
return customerName;
}
public void setCustomerName(String customerName) {
this.customerName = customerName;
}
public VipCard getVipcard() {
return vipcard;
}
public void setVipcard(VipCard vipcard) {
this.vipcard = vipcard;
}
}
B、
package com.creasoft.entity2;
public class VipCard {
private long vid;
private float discount;
private Customer customer;
public VipCard() {
super();
}
public VipCard(float discount, Customer customer) {
super();
this.discount = discount;
this.customer = customer;
}
public long getVid() {
return vid;
}
public void setVid(long vid) {
this.vid = vid;
}
public float getDiscount() {
return discount;
}
public void setDiscount(float discount) {
this.discount = discount;
}
public Customer getCustomer() {
return customer;
}
public void setCustomer(Customer customer) {
this.customer = customer;
}
2）映射文件
A、主导类的映射文件：<one-to-one>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.creasoft.entity2.Customer" table="vcustomer">
<id name ="cid" type="long">
<generator class="identity"></generator>
</id>
<property name="customerName" type="string"></property>
<one-to-one name="vipcard"
class="com.creasoft.entity2.VipCard"
cascade="all"></one-to-one>
</class>
</hibernate-mapping>
B、
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.creasoft.entity2.VipCard" table="vipcard">
<id name="vid" type="long">
<generator class="foreign">
<!—customer必须与vipcard类中的属性名相同
<param name="property">customer</param>
</generator>
</id>
<!-- constrained为true表示name既是主键又是外键 -->
<property name="discount" type="float"></property>
<one-to-one name="customer"
constrained="true"
class="com.creasoft.entity2.Customer"
cascade="save-update"></one-to-one>
</class>
</hibernate-mapping>
1.4 3)插入一条数据
Session session = Hibernateutil.getSession();
//开始事务
Transaction tsaction = session.beginTransaction();
//数据的操作
Customer cs = new Customer();
cs.setCustomerName("chen");
VipCard vc = new VipCard();
vc.setDiscount(0.8f);
vc.setCustomer(cs);
cs.setVipcard(vc);
session.save(cs);
//提交事务
tsaction.commit();
//关闭session
session.close();
}
8、多对多
1）实体类
A、多
package com.creasoft.entity3;
import java.util.HashSet;
import java.util.Set;
public class Customer {
private long cid;
private String customerName;
private Set<Address> addresses = new HashSet<Address>();
public Customer() {
super();
}
public Customer(String customerName, Set<Address> addresses) {
super();
this.customerName = customerName;
this.addresses = addresses;
}
public long getCid() {
return cid;
}
public void setCid(long cid) {
this.cid = cid;
}
public String getCustomerName() {
return customerName;
}
public void setCustomerName(String customerName) {
this.customerName = customerName;
}
public Set<Address> getAddresses() {
return addresses;
}
public void setAddresses(Set<Address> addresses) {
this.addresses = addresses;
}
}
B、多
package com.creasoft.entity3;
import java.util.HashSet;
import java.util.Set;
public class Address {
private long aid;
private String addressDetail;
private Set<Customer> customers = new HashSet<Customer>();
public Address() {
super();
}
public Address(String addressDetail, Set<Customer> customers) {
super();
this.addressDetail = addressDetail;
this.customers = customers;
}
public long getAid() {
return aid;
}
public void setAid(long aid) {
this.aid = aid;
}
public String getAddressDetail() {
return addressDetail;
}
public void setAddressDetail(String addressDetail) {
this.addressDetail = addressDetail;
}
public Set<Customer> getCustomers() {
return customers;
}
public void setCustomers(Set<Customer> customers) {
this.customers = customers;
}
}
2）映射文件：
有且只能在一边必须要加上inverse="true"，不然出错
A、set标签中<many-to-many>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.creasoft.entity3.Customer" table="acutstomer">
<id name="cid" type="long">
<generator class="identity"></generator>
</id>
<property name="customerName" type="string"></property>
<!-- 两边的table，column必须要一致。这边key中column的必须与另一边many-to-many中column-->
<set name="addresses" inverse="true" table="customer_address">
<key column="customerid"></key>
<many-to-many class="com.creasoft.entity3.Address"
column="addressid">
</many-to-many>
</set>
</class>
</hibernate-mapping>
B、set标签中<many-to-many>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.creasoft.entity3.Address">
<id name="aid">
<generator class="identity"></generator>
</id>
<property name="addressDetail"></property>
<!-- 两边的table，column必须要一致。这边key中column的必须与另一边many-to-many中column-->
<set name="customers" table="customer_address">
<key column="addressid"></key>
<many-to-many class="com.creasoft.entity3.Customer"
column="customerid"></many-to-many>
</set>
</class>
</hibernate-mapping>
3）插入数据库中
把属性都加入两集合中
package com.creasoft.test;
import java.util.Date;
import org.hibernate.Session;
import org.hibernate.Transaction;
import com.creasoft.entity3.Customer;
import com.creasoft.entity3.Address;
import com.creasoft.util.Hibernateutil;
public class Test03 {
public static void main(String[] args) {
Session session =Hibernateutil.getSession();
Transaction ts = session.beginTransaction();
//对数据库的一些操作
Customer cs1 = new Customer();
Customer cs2 = new Customer();
cs1.setCustomerName("盛开");
cs2.setCustomerName("sk");
Address ad1= new Address();
Address ad2 = new Address();
ad1.setAddressDetail("长沙");
ad2.setAddressDetail("香港");
cs1.getAddresses().add(ad1);
cs1.getAddresses().add(ad2);
ad1.getCustomers().add(cs1);
ad1.getCustomers().add(cs2);
ad1s =cs2.getAddresses();
ad1s.add(ad1);
cs2.getAddresses().add(ad2);
ad2.getCustomers().add(cs1);
ad2.getCustomers().add(cs2);
//set集合到customer中
Cs2.setAddresses(ad1s);
session.save(cs1);
session.save(cs2);
session.save(ad1);
session.save(ad2);
ts.commit();
session.close();
}
}
9、 Hibernate对数据库的基本操作依赖的五个核心接口：
Configuration界面：配置Hibernate,预启动Hibernate,创建SessionFactory对象
SessionFactory界面：初始化Hibernate,充当数据源代理,创建Session对象
Session界面：负责保存,更新,删除,加载和查询对象
Transaction界面：管理事务
Query和Criteria界面：执行数据库查询
10、hql
1）、Query接口：生命周期与session绑定
package com.creasoft.test;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import com.creasoft.entity.SCourse;
import com.creasoft.util.Hibernateutil;
public class Test2 {
public static void main(String[] args) {
Session session = Hibernateutil.getSesion();
<!—其中的scourse是类名
Query query = session.createQuery("FROM SCourse");
<!—list只能适用小量的数据，效率比较高，容易产生内存溢出
List<SCourse> c = query.list();
for(SCourse s: c){
System.out.println(s.getCourseName());
}
<!—iterator能查找大量的数据，但效率低
// Iterator<SCourse> iterator = query.iterate();
//
// while(iterator.hasNext()){
// SCourse s = iterator.next();
// System.out.println(s.getCourseName());
// }
session.close();
}
}
2）、增删改查的封装
//增加用户
Static void addUser(User user){
Session s=null;
Transaction tx=null;
Try{
S=Hibernateutil.getSession();
tx=s.beginTransaction();
s.save(User);
tx.commit();
}catch(HibernateException e){
If(tx!=null){
tx.rollback();
throw e;
}finally{
If(s!=null){
s.close();
}
}
}
//修改
public static void update(User user){
Session s=null;
Transaction ts=null;
try{
s=sessionFactory.openSession();
ts=s.beginTransaction();
s.update(user);
ts.commit();
}finally{
if(s!=null){
s.close();
}
}
}
//删除
public static void delete(User user){
Session s=null;
Transaction ts=null;
try{
s=sessionFactory.openSession();
ts=s.beginTransaction();
s.delete(user);
ts.commit();
}finally{
if(s!=null){
s.close();
}
}
}
2、 查询
1） Hql：是对对象操作，而不是表。
在sql中能用的方法在hql中一定能够使用，只是hql操作的是对象，sql是表。
a、 模糊查询
public List<TicketSite> findByTname(String Tname) {
List<TicketSite> list = new ArrayList<TicketSite>();
Session session = HibernateUtil.getSession();
// TicketSite是一个类名，而不是表名
String hql = "from TicketSite t where t.train.Tname like ‘%"+Tname+“%’”;
Query query = session.createQuery(hql);
query.setString(0, Tname);
list = query.list();
return list;
}
1.4.1.1 B、条件查询
1.4.2 //根据站名查询
public List<TicketSite> findBySites(String start, String end) {
List<TicketSite> list = new ArrayList<TicketSite>();
Session session = HibernateUtil.getSession();
String hql = "from TicketSite where siteFrom=? and siteTo=?";
Query query = session.createQuery(hql);
query.setString(0, start);
query.setString(1,end);
list = query.list();
return list;
}
//根据车次查询
public List<TicketSite> findByTname(String Tname) {
List<TicketSite> list = new ArrayList<TicketSite>();
Session session = HibernateUtil.getSession();
String hql = "from TicketSite t where t.train.Tname=?";
Query query = session.createQuery(hql);
query.setString(0, Tname);
list = query.list();
return list;
}
1.4.3 返回的是一个实体
//根据订单的编号查找订单的信息
public Order findOrder(long orderNumberd) {
Order od = new Order();
Session session = HibernateUtil.getSession();
Transaction ts = session.beginTransaction();
String hql="from Order where orderNumberd = ?";
Query query = session.createQuery(hql);
query.setLong(0, orderNumberd);
od = (Order)query.uniqueResult();
ts.commit();
session.close();
return od;
}
2） get、load
session.get(Clazz, id);
session.load(Clazz, id);
1.5 级联删除
删除多的一边,先要使一的一边为空.
1.5.1 一的那边
//根据id，修改订单详细
public boolean updateOrderProduct(OrderProduct op){
boolean flag =false;
Session session = HibernateUtil.getSession();
Transaction ts = session.beginTransaction();
System.out.println(op.getId());
op = (OrderProduct)session.get(OrderProduct.class,op.getId());
op.setOrder(null);
session.update(op);
flag = true;
ts.commit();
session.close();
return flag;
}
1.5.2 多
//删除订单中的商品
public boolean delete(OrderProduct op){
boolean flag = false;
Session session = HibernateUtil.getSession();
Transaction ts = session.beginTransaction();
op = (OrderProduct)session.get(OrderProduct.class, op.getId());
session.delete(op);
flag = true;
ts.commit();
session.close();
return flag;
}
1.5.3 业务层
//删除订单中的商品
public boolean delete(OrderProduct op){
boolean flag = false;
IOrderDao orderDao = new OrderDaoImpl();
orderDao.updateOrderProduct(op);
flag = orderDao.delete(op);
return flag;
}
1.6 级联插入
先要插入多的一面
1.6.1 Dao层
1.6.1.1 查找到一的实体
//根据id查找订单信息
public Order findOd(long id){
Order od = new Order();
Session session = HibernateUtil.getSession();
String hql = "from Order where id = ?";
Query query = session.createQuery(hql);
query.setLong(0, id);
od = (Order)query.uniqueResult();
session.close();
return od;
}
1.6.1.2 多
//插入操作历史
public boolean insertOrderHistory(Order od, OrderHistory oh){
boolean flag = false;
Session session = HibernateUtil.getSession();
Transaction ts = session.beginTransaction();
oh.setOd(od);
session.save(oh);
session.update(od);
flag = true;
ts.commit();
session.close();
return flag;
}
1.6.2 业务层
//判断插入的订单操作历史是否成功
public boolean insertOrderHistory(long id, OrderHistory oh){
boolean flag = false;
IOrderDao orderDao = new OrderDaoImpl();
//取得订单
Order od = orderDao.findOd(id);
flag = orderDao.insertOrderHistory(od, oh);
return flag;
}
分享到：
发表评论
-
hibernate 的加载
2012-06-20 22:39 01.lazy应用范围： lazy只有在session打开状态 ... -
hibernate 的加载
2012-06-20 22:39 6431.lazy应用范围： lazy只有在session打开状态 ... -
hibernate的缓存
2012-06-20 22:21 6441.配置二级缓存 a.具体的配置位置位于hibernate. ... -
cascade 和inverse
2012-06-20 21:35 624总体上说inverse是指定哪个表作为维护端，cascade则 ... -
Hibernate主键生成策略
2012-06-20 20:32 6901、自动增长identity 适用于MySQL、DB2、M ... -
hibernate 的状态
2012-06-19 19:54 670在Hibernate中有三种状态，对它的深入理解，才能更好的理 ...
相关推荐
【作品名称】：基于servlet+jsp+mysql实现的影视管理系统【课程设计】 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】： 基于servlet+jsp+mysql实现的影视管理系统【课程设计】 基于servlet+jsp+mysql实现的影视管理系统【课程设计】 Java Web课程设计，基于servlet+jsp+ajax+mysql做的影视管理系统 运行环境： Tomcat 9.0 JDK 1.8 MySQL 8.0 后台管理账号密码均为：root，项目依赖：lib 目录 【资源声明】：本资源作为“参考资料”而不是“定制需求”，代码只能作为参考，不能完全复制照搬。需要有一定的基础看懂代码，自行调试代码并解决报错，能自行添加功能修改代码。
kernel-5.15-ky10-x86.tar.gz
【作品名称】：基于AT89C51 单片机为核心器件，程序设计采用C 语言，Keil 软件编译程序，配以相关外围接口电路，实现了方波、锯齿波、正弦波、三角波、梯形波五种特定波形的产生【论文+源码】 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】：本设计中的波形发生器系统要求基于51单片机，因此选用以AT89C51单片机作为整个系统的控制核心，应用其强大的接口功能，构成整个波形发生器的硬件系统。使用C 语言对单片机编程可产生相应的正弦波，方波，三角波，锯齿波梯形波波形信号。在程序运行时，当接收到按键信息后，需要输出某种波形时，调用相应的中断服务子程序和波形发生程序，经电路的数/模转换器和运算放大器处理后，从信号发生器的输出端口输出即可得到要求的波形。 当需要改变频率时只需要改变单片机的波形发生程序中的递增或者递减变量即可。 【资源声明】：本资源作为“参考资料”而不是“定制需求”，代码只能作为参考，不能完全复制照搬。需要有一定的基础看懂代码，自行调试代码并解决报错，能自行添加功能修改代码。
基于java的法律咨询系统设计与实现.docx
适用于元营销 API 的 Python SDK适用于 Python 的 Facebook Business SDK 介绍Facebook Business SDK是一站式服务，可帮助我们的合作伙伴更好地服务于他们的业务。合作伙伴正在使用多个 Facebook API 来满足其客户的需求。采用所有这些 API 并在各个平台上保持最新状态可能非常耗时，而且最终会造成高昂的成本。为此，Facebook 开发了 Business SDK，将其许多 API 捆绑到一个 SDK 中，以简化实施和维护。Business SDK 是 Marketing API SDK 的升级版，其中包括 Marketing API 以及来自不同平台（如 Pages、Business Manager、Instagram 等）的许多 Facebook API。快速入门商业SDK入门指南Python 目前是我们第三方开发人员最常用的语言。是一个 Python 包，它提供了您的 Python 应用程序与Business SDK 内的 Facebook APIfacebook_business之间的
数学建模培训资料 数学建模实战题目真题答案解析解题过程&论文报告 公交车调度的运作数学模型 共12页.pdf
smart-http 是一款可编程的 Http 应用微内核，方便用户根据自身需求进行 Server 或 Client 的应用开发。支持GET、POST的 HTTP 请求。提供了 URL 路由组件，可以快速搭建一套静态服务器。支持部分 RFC2612 规范，后续会逐渐完善。支持 Https 协议，由 smart-socket 为其赋能。具备文件上传的能力。支持 websocket、Cookie支持 Server、Client 开发
新闻资讯系统 微信小程序+SpringBoot毕业设计 源码+数据库+论文+启动教程 项目启动教程：https://www.bilibili.com/video/BV1oiBpYcEBp
高校师生工作室-JAVA-基于微信小程序的高校师生工作室管理系统的设计与实现
基于java的常见小儿疾病中医护理系统设计与实现.docx
本教程播放列表涵盖了 Python 中的数据结构和算法。每个教程都有数据结构或算法背后的理论、BIG O 复杂性分析和可供练习的练习。使用 Python 的数据结构和算法本教程涵盖了 Python 中的数据结构和算法。每个教程都包含数据结构或算法背后的理论、BIG O 复杂度分析以及可供练习的练习。要观看视频，您可以访问播放列表https://www.youtube.com/playlist?list=PLeo1K3hjS3uu_n_a__MI_KktGTLYopZ12订阅 codebasics youtube 频道https://www.youtube.com/c/codebasics
数学建模学习资料 蒙特卡罗方法课件教程 第2章.随机数 共29页.pptx
python实现基于CNN网络的新闻数据集文本分类源码+数据集（Python期末大作业），个人大三学期的期末大作业、经导师指导并认可通过的高分大作业设计项目，评审分98分。主要针对计算机相关专业的正在做大作业的学生和需要项目实战练习的学习者，可作为课程设计、期末大作业。 python实现基于CNN网络的新闻数据集文本分类源码+数据集（Python期末大作业）python实现基于CNN网络的新闻数据集文本分类源码+数据集（Python期末大作业），个人大三学期的期末大作业、经导师指导并认可通过的高分大作业设计项目，评审分98分。主要针对计算机相关专业的正在做大作业的学生和需要项目实战练习的学习者，可作为课程设计、期末大作业。python实现基于CNN网络的新闻数据集文本分类源码+数据集（Python期末大作业），个人大三学期的期末大作业、经导师指导并认可通过的高分大作业设计项目，评审分98分。主要针对计算机相关专业的正在做大作业的学生和需要项目实战练习的学习者，可作为课程设计、期末大作业。python实现基于CNN网络的新闻数据集文本分类源码+数据集（Python期末大作业），个人大
中小学知识产权教育试点学校申报表.doc
基于django的音乐推荐系统.zip
在建工程涉及专项行动情况检查表.docx
本项目是一个基于Python技术的学生管理系统，采用Django框架进行开发，旨在为计算机相关专业的学生提供一个实践性强、功能全面的管理系统，以帮助他们完成毕业设计或进行项目实战练习。 系统实现了对学生信息、课程信息、成绩、考勤等多方面的管理功能。学生信息管理包括学生基本信息的增删改查；课程信息管理允许管理员设置课程信息，包括课程名称、授课老师、学分等；成绩管理功能使学生和教师能够录入、查看和修改成绩；考勤管理则方便教师记录学生的出勤情况。 该项目采用B/S架构，前端使用HTML、CSS、JavaScript等技术，后端使用Python语言和Django框架，数据库采用MySQL。Django框架提供了强大的后台管理功能，使得系统管理更加便捷。 通过开发这个项目，学生不仅能提升自己的编程能力，还能学习到如何构建一个实际应用的系统，对于即将步入职场的学生来说，具有很高的实用价值。
适用于 Python 的 Splunk 软件开发工具包参考文档适用于 Python 的 Splunk Enterprise 软件开发工具包版本 2.1.0适用于 Python 的 Splunk Enterprise 软件开发套件 (SDK) 包含库代码，旨在使开发人员能够使用 Splunk 平台构建应用程序。Splunk 平台是一个搜索引擎和分析环境，它使用分布式 map-reduce 架构来有效地索引、搜索和处理大型时变数据集。Splunk 平台深受系统管理员的欢迎，用于聚合和监控 IT 机器数据、安全性、合规性以及各种其他场景，这些场景都需要有效地从大量时间序列数据中索引、搜索、分析和生成实时通知。Splunk 开发者平台使开发人员能够利用 Splunk 平台所使用的相同技术来构建令人兴奋的新应用程序。开始使用 Python 版 Splunk SDK开始使用 Python 版 Splunk Enterprise SDKSplunk Enterprise SDK for Python 包含库代码，其示例位于splunk-app-examples存储库
分布式事务练习
家庭财务管理系统 微信小程序+SSM毕业设计 源码+数据库+论文+启动教程 项目启动教程：https://www.bilibili.com/video/BV1BfB2YYEnS